effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.All.ML | val hd: list 'a -> ML 'a | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list" | val hd: list 'a -> ML 'a
let hd = | true | null | false | function
| hd :: tl -> hd
| _ -> failwith "head of empty list" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val hd: list 'a -> ML 'a | [] | FStar.List.hd | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.list 'a -> FStar.All.ML 'a | {
"end_col": 38,
"end_line": 34,
"start_col": 9,
"start_line": 32
} |
FStar.All.ML | val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let iteri f x = iteri_aux 0 f x | val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = | true | null | false | iteri_aux 0 f x | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.int",
"Prims.unit",
"Prims.list",
"FStar.List.iteri_aux"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit | [] | FStar.List.iteri | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: Prims.int -> _: 'a -> FStar.All.ML Prims.unit) -> x: Prims.list 'a -> FStar.All.ML Prims.unit | {
"end_col": 31,
"end_line": 109,
"start_col": 16,
"start_line": 109
} |
FStar.All.ML | val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mapi f l = mapi_init f l 0 | val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = | true | null | false | mapi_init f l 0 | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.int",
"Prims.list",
"FStar.List.mapi_init"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b) | [] | FStar.List.mapi | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: Prims.int -> _: 'a -> FStar.All.ML 'b) -> l: Prims.list 'a -> FStar.All.ML (Prims.list 'b) | {
"end_col": 30,
"end_line": 141,
"start_col": 15,
"start_line": 141
} |
FStar.All.ML | val init: list 'a -> ML (list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list" | val init: list 'a -> ML (list 'a)
let rec init = | true | null | false | function
| [_] -> []
| hd :: tl -> hd :: (init tl)
| _ -> failwith "init of empty list" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"FStar.List.init",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val init: list 'a -> ML (list 'a) | [
"recursion"
] | FStar.List.init | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.list 'a -> FStar.All.ML (Prims.list 'a) | {
"end_col": 38,
"end_line": 68,
"start_col": 15,
"start_line": 65
} |
FStar.All.ML | val tail: list 'a -> ML (list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list" | val tail: list 'a -> ML (list 'a)
let tail = | true | null | false | function
| hd :: tl -> tl
| _ -> failwith "tail of empty list" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tail: list 'a -> ML (list 'a) | [] | FStar.List.tail | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.list 'a -> FStar.All.ML (Prims.list 'a) | {
"end_col": 38,
"end_line": 43,
"start_col": 11,
"start_line": 41
} |
FStar.All.ML | val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length" | val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = | true | null | false | match l1, l2, l3 with
| [], [], [] -> []
| hd1 :: tl1, hd2 :: tl2, hd3 :: tl3 -> (f hd1 hd2 hd3) :: (map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple3",
"Prims.Nil",
"Prims.Cons",
"FStar.List.map3",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd) | [
"recursion"
] | FStar.List.map3 | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
f: (_: 'a -> _: 'b -> _: 'c -> FStar.All.ML 'd) ->
l1: Prims.list 'a ->
l2: Prims.list 'b ->
l3: Prims.list 'c
-> FStar.All.ML (Prims.list 'd) | {
"end_col": 65,
"end_line": 177,
"start_col": 26,
"start_line": 174
} |
FStar.All.ML | val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length" | val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = | true | null | false | match l1, l2 with
| [], [] -> []
| hd1 :: tl1, hd2 :: tl2 -> (f hd1 hd2) :: (map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"Prims.Cons",
"FStar.List.map2",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c) | [
"recursion"
] | FStar.List.map2 | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> _: 'b -> FStar.All.ML 'c) -> l1: Prims.list 'a -> l2: Prims.list 'b
-> FStar.All.ML (Prims.list 'c) | {
"end_col": 62,
"end_line": 166,
"start_col": 23,
"start_line": 163
} |
Prims.Tot | val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mapT = FStar.List.Tot.map | val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = | false | null | false | FStar.List.Tot.map | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b) | [] | FStar.List.mapT | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: (_: 'a -> 'b) -> _: Prims.list 'a -> Prims.list 'b | {
"end_col": 29,
"end_line": 124,
"start_col": 11,
"start_line": 124
} |
FStar.All.ML | val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length" | val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = | true | null | false | match l1, l2 with
| [], [] -> true
| hd1 :: tl1, hd2 :: tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.forall2",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool | [
"recursion"
] | FStar.List.forall2 | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> _: 'b -> FStar.All.ML Prims.bool) -> l1: Prims.list 'a -> l2: Prims.list 'b
-> FStar.All.ML Prims.bool | {
"end_col": 62,
"end_line": 236,
"start_col": 26,
"start_line": 233
} |
FStar.All.ML | val zip: list 'a -> list 'b -> ML (list ('a * 'b)) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec zip l1 l2 = match l1,l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (hd1,hd2)::(zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length" | val zip: list 'a -> list 'b -> ML (list ('a * 'b))
let rec zip l1 l2 = | true | null | false | match l1, l2 with
| [], [] -> []
| hd1 :: tl1, hd2 :: tl2 -> (hd1, hd2) :: (zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"Prims.Cons",
"FStar.List.zip",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *)
val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2
(** List of tuples **)
(** [zip] takes two lists [x1, ..., xn] and [y1, ..., yn] and returns
the list of pairs [(x1, y1), ..., (xn, yn)]. Raises an exception if
the two lists have different lengths. Named as in: Haskell *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val zip: list 'a -> list 'b -> ML (list ('a * 'b)) | [
"recursion"
] | FStar.List.zip | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | l1: Prims.list 'a -> l2: Prims.list 'b -> FStar.All.ML (Prims.list ('a * 'b)) | {
"end_col": 62,
"end_line": 305,
"start_col": 20,
"start_line": 302
} |
FStar.All.ML | val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length" | val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = | true | null | false | match l1, l2 with
| [], [] -> a
| hd1 :: tl1, hd2 :: tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length" | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.fold_left2",
"FStar.All.failwith"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's | [
"recursion"
] | FStar.List.fold_left2 | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 's -> _: 'a -> _: 'b -> FStar.All.ML 's) -> a: 's -> l1: Prims.list 'a -> l2: Prims.list 'b
-> FStar.All.ML 's | {
"end_col": 62,
"end_line": 196,
"start_col": 31,
"start_line": 193
} |
FStar.All.ML | val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl | val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = | true | null | false | match x with
| [] -> ()
| a :: tl ->
f i a;
iteri_aux (i + 1) f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.int",
"Prims.unit",
"Prims.list",
"FStar.List.iteri_aux",
"Prims.op_Addition"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit | [
"recursion"
] | FStar.List.iteri_aux | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | i: Prims.int -> f: (_: Prims.int -> _: 'a -> FStar.All.ML Prims.unit) -> x: Prims.list 'a
-> FStar.All.ML Prims.unit | {
"end_col": 40,
"end_line": 103,
"start_col": 26,
"start_line": 101
} |
FStar.All.ML | val nth: list 'a -> int -> ML 'a | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1) | val nth: list 'a -> int -> ML 'a
let rec nth l n = | true | null | false | if n < 0
then failwith "nth takes a non-negative integer as input"
else
if n = 0
then
match l with
| [] -> failwith "not enough elements"
| hd :: _ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _ :: tl -> nth tl (n - 1) | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"Prims.int",
"Prims.op_LessThan",
"FStar.All.failwith",
"Prims.bool",
"Prims.op_Equality",
"FStar.List.nth",
"Prims.op_Subtraction"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nth: list 'a -> int -> ML 'a | [
"recursion"
] | FStar.List.nth | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | l: Prims.list 'a -> n: Prims.int -> FStar.All.ML 'a | {
"end_col": 33,
"end_line": 87,
"start_col": 2,
"start_line": 77
} |
FStar.All.ML | val index: ('a -> ML bool) -> list 'a -> ML int | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let index f l =
let rec index l i : ML int =
match l with
| [] ->
failwith "List.index: not found"
| hd :: tl ->
if f hd then
i
else
index tl (i + 1)
in
index l 0 | val index: ('a -> ML bool) -> list 'a -> ML int
let index f l = | true | null | false | let rec index l i : ML int =
match l with
| [] -> failwith "List.index: not found"
| hd :: tl -> if f hd then i else index tl (i + 1)
in
index l 0 | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"Prims.int",
"FStar.All.failwith",
"Prims.op_Addition"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *)
val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2
(** List of tuples **)
(** [zip] takes two lists [x1, ..., xn] and [y1, ..., yn] and returns
the list of pairs [(x1, y1), ..., (xn, yn)]. Raises an exception if
the two lists have different lengths. Named as in: Haskell *)
val zip: list 'a -> list 'b -> ML (list ('a * 'b))
let rec zip l1 l2 = match l1,l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (hd1,hd2)::(zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** Sorting (implemented as quicksort) **)
(** [sortWith compare l] returns the list [l'] containing the elements
of [l] sorted along the comparison function [compare], in such a way
that if [compare x y > 0], then [x] appears before [y] in [l']. (Hides
[List.Tot.sortWith], which requires, at type-checking time, [compare]
to be a pure total function.) *)
val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a)
let rec sortWith f = function
| [] -> []
| pivot::tl ->
let hi, lo = partition (fun x -> f pivot x > 0) tl in
sortWith f lo@(pivot::sortWith f hi)
(** [splitAt n l] returns the pair of lists [(l1, l2)] such that [l1]
contains the first [n] elements of [l] and [l2] contains the
rest. Raises an exception if [l] has fewer than [n] elements. *)
val splitAt: nat -> list 'a -> ML (list 'a * list 'a)
let rec splitAt n l =
if n = 0 then [], l
else
match l with
| [] -> failwith "splitAt index is more that list length"
| hd::tl ->
let l1, l2 = splitAt (n - 1) tl in
hd::l1, l2
(** [filter_map f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Implemented
here as a tail-recursive version of [choose] *)
let filter_map (f:'a -> ML (option 'b)) (l:list 'a) : ML (list 'b) =
let rec filter_map_acc (acc:list 'b) (l:list 'a) : ML (list 'b) =
match l with
| [] ->
rev acc
| hd :: tl ->
match f hd with
| Some hd ->
filter_map_acc (hd :: acc) tl
| None ->
filter_map_acc acc tl
in
filter_map_acc [] l
(** [index f l] returns the position index in list [l] of the first
element [x] in [l] such that [f x] holds. Raises an exception if no
such [x] exists. TODO: rename this function (it hides List.Tot.index
which has a completely different semantics.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val index: ('a -> ML bool) -> list 'a -> ML int | [] | FStar.List.index | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML Prims.bool) -> l: Prims.list 'a -> FStar.All.ML Prims.int | {
"end_col": 11,
"end_line": 367,
"start_col": 15,
"start_line": 356
} |
FStar.All.ML | val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl | val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = | true | null | false | match l with
| [] -> None
| hd :: tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"FStar.Pervasives.Native.option",
"Prims.list",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"FStar.List.tryPick"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b) | [
"recursion"
] | FStar.List.tryPick | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML (FStar.Pervasives.Native.option 'b)) -> l: Prims.list 'a
-> FStar.All.ML (FStar.Pervasives.Native.option 'b) | {
"end_col": 31,
"end_line": 268,
"start_col": 22,
"start_line": 263
} |
FStar.All.ML | val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl) | val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = | true | null | false | match l with
| [] -> []
| hd :: tl -> append (f hd) (collect f tl) | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.append",
"FStar.List.collect"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b) | [
"recursion"
] | FStar.List.collect | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML (Prims.list 'b)) -> l: Prims.list 'a -> FStar.All.ML (Prims.list 'b) | {
"end_col": 44,
"end_line": 247,
"start_col": 22,
"start_line": 245
} |
FStar.All.ML | val for_all: ('a -> ML bool) -> list 'a -> ML bool | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false | val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = | true | null | false | match l with
| [] -> true
| hd :: tl -> if f hd then for_all f tl else false | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"FStar.List.for_all"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val for_all: ('a -> ML bool) -> list 'a -> ML bool | [
"recursion"
] | FStar.List.for_all | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML Prims.bool) -> l: Prims.list 'a -> FStar.All.ML Prims.bool | {
"end_col": 52,
"end_line": 225,
"start_col": 22,
"start_line": 223
} |
FStar.All.ML | val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec sortWith f = function
| [] -> []
| pivot::tl ->
let hi, lo = partition (fun x -> f pivot x > 0) tl in
sortWith f lo@(pivot::sortWith f hi) | val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a)
let rec sortWith f = | true | null | false | function
| [] -> []
| pivot :: tl ->
let hi, lo = partition (fun x -> f pivot x > 0) tl in
sortWith f lo @ (pivot :: sortWith f hi) | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.int",
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.op_At",
"Prims.Cons",
"FStar.List.sortWith",
"FStar.Pervasives.Native.tuple2",
"FStar.List.partition",
"Prims.op_GreaterThan",
"Prims.bool"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *)
val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2
(** List of tuples **)
(** [zip] takes two lists [x1, ..., xn] and [y1, ..., yn] and returns
the list of pairs [(x1, y1), ..., (xn, yn)]. Raises an exception if
the two lists have different lengths. Named as in: Haskell *)
val zip: list 'a -> list 'b -> ML (list ('a * 'b))
let rec zip l1 l2 = match l1,l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (hd1,hd2)::(zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** Sorting (implemented as quicksort) **)
(** [sortWith compare l] returns the list [l'] containing the elements
of [l] sorted along the comparison function [compare], in such a way
that if [compare x y > 0], then [x] appears before [y] in [l']. (Hides
[List.Tot.sortWith], which requires, at type-checking time, [compare]
to be a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a) | [
"recursion"
] | FStar.List.sortWith | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> _: 'a -> FStar.All.ML Prims.int) -> _: Prims.list 'a -> FStar.All.ML (Prims.list 'a) | {
"end_col": 41,
"end_line": 319,
"start_col": 21,
"start_line": 315
} |
FStar.All.ML | val splitAt: nat -> list 'a -> ML (list 'a * list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec splitAt n l =
if n = 0 then [], l
else
match l with
| [] -> failwith "splitAt index is more that list length"
| hd::tl ->
let l1, l2 = splitAt (n - 1) tl in
hd::l1, l2 | val splitAt: nat -> list 'a -> ML (list 'a * list 'a)
let rec splitAt n l = | true | null | false | if n = 0
then [], l
else
match l with
| [] -> failwith "splitAt index is more that list length"
| hd :: tl ->
let l1, l2 = splitAt (n - 1) tl in
hd :: l1, l2 | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.nat",
"Prims.list",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"FStar.All.failwith",
"Prims.Cons",
"FStar.List.splitAt",
"Prims.op_Subtraction"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *)
val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2
(** List of tuples **)
(** [zip] takes two lists [x1, ..., xn] and [y1, ..., yn] and returns
the list of pairs [(x1, y1), ..., (xn, yn)]. Raises an exception if
the two lists have different lengths. Named as in: Haskell *)
val zip: list 'a -> list 'b -> ML (list ('a * 'b))
let rec zip l1 l2 = match l1,l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (hd1,hd2)::(zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** Sorting (implemented as quicksort) **)
(** [sortWith compare l] returns the list [l'] containing the elements
of [l] sorted along the comparison function [compare], in such a way
that if [compare x y > 0], then [x] appears before [y] in [l']. (Hides
[List.Tot.sortWith], which requires, at type-checking time, [compare]
to be a pure total function.) *)
val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a)
let rec sortWith f = function
| [] -> []
| pivot::tl ->
let hi, lo = partition (fun x -> f pivot x > 0) tl in
sortWith f lo@(pivot::sortWith f hi)
(** [splitAt n l] returns the pair of lists [(l1, l2)] such that [l1]
contains the first [n] elements of [l] and [l2] contains the
rest. Raises an exception if [l] has fewer than [n] elements. *)
val splitAt: nat -> list 'a -> ML (list 'a * list 'a) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val splitAt: nat -> list 'a -> ML (list 'a * list 'a) | [
"recursion"
] | FStar.List.splitAt | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | n: Prims.nat -> l: Prims.list 'a -> FStar.All.ML (Prims.list 'a * Prims.list 'a) | {
"end_col": 18,
"end_line": 332,
"start_col": 2,
"start_line": 326
} |
FStar.All.ML | val map: ('a -> ML 'b) -> list 'a -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl | val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = | true | null | false | match x with
| [] -> []
| a :: tl -> f a :: map f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"FStar.List.map"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map: ('a -> ML 'b) -> list 'a -> ML (list 'b) | [
"recursion"
] | FStar.List.map | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML 'b) -> x: Prims.list 'a -> FStar.All.ML (Prims.list 'b) | {
"end_col": 26,
"end_line": 118,
"start_col": 18,
"start_line": 116
} |
FStar.All.ML | val filter: ('a -> ML bool) -> list 'a -> ML (list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl | val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = | true | null | false | function
| [] -> []
| hd :: tl -> if f hd then hd :: (filter f tl) else filter f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"FStar.List.filter"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val filter: ('a -> ML bool) -> list 'a -> ML (list 'a) | [
"recursion"
] | FStar.List.filter | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML Prims.bool) -> _: Prims.list 'a -> FStar.All.ML (Prims.list 'a) | {
"end_col": 61,
"end_line": 216,
"start_col": 19,
"start_line": 214
} |
FStar.All.ML | val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x) | val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = | true | null | false | match l with
| [] -> x
| hd :: tl -> f hd (fold_right f tl x) | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.List.fold_right"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b | [
"recursion"
] | FStar.List.fold_right | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> _: 'b -> FStar.All.ML 'b) -> l: Prims.list 'a -> x: 'b -> FStar.All.ML 'b | {
"end_col": 38,
"end_line": 205,
"start_col": 27,
"start_line": 203
} |
FStar.All.ML | val iter: ('a -> ML unit) -> list 'a -> ML unit | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl | val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = | true | null | false | match x with
| [] -> ()
| a :: tl ->
let _ = f a in
iter f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.unit",
"Prims.list",
"FStar.List.iter"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val iter: ('a -> ML unit) -> list 'a -> ML unit | [
"recursion"
] | FStar.List.iter | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML Prims.unit) -> x: Prims.list 'a -> FStar.All.ML Prims.unit | {
"end_col": 37,
"end_line": 96,
"start_col": 19,
"start_line": 94
} |
FStar.All.ML | val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl | val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = | true | null | false | function
| [] -> []
| a :: tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.op_At",
"FStar.List.concatMap"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b) | [
"recursion"
] | FStar.List.concatMap | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML (Prims.list 'b)) -> _: Prims.list 'a -> FStar.All.ML (Prims.list 'b) | {
"end_col": 12,
"end_line": 155,
"start_col": 22,
"start_line": 150
} |
FStar.All.ML | val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1)) | val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = | true | null | false | match l with
| [] -> []
| hd :: tl -> (f i hd) :: (mapi_init f tl (i + 1)) | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.int",
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"FStar.List.mapi_init",
"Prims.op_Addition"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b) | [
"recursion"
] | FStar.List.mapi_init | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: Prims.int -> _: 'a -> FStar.All.ML 'b) -> l: Prims.list 'a -> i: Prims.int
-> FStar.All.ML (Prims.list 'b) | {
"end_col": 48,
"end_line": 133,
"start_col": 26,
"start_line": 131
} |
FStar.All.ML | val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl | val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = | true | null | false | match y with
| [] -> x
| hd :: tl -> fold_left f (f x hd) tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.list",
"FStar.List.fold_left"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a | [
"recursion"
] | FStar.List.fold_left | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> _: 'b -> FStar.All.ML 'a) -> x: 'a -> y: Prims.list 'b -> FStar.All.ML 'a | {
"end_col": 37,
"end_line": 185,
"start_col": 26,
"start_line": 183
} |
FStar.All.ML | val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl | val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = | true | null | false | match l with
| [] -> []
| hd :: tl ->
match f hd with
| Some x -> x :: (choose f tl)
| None -> choose f tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"FStar.Pervasives.Native.option",
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"FStar.List.choose"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b) | [
"recursion"
] | FStar.List.choose | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML (FStar.Pervasives.Native.option 'b)) -> l: Prims.list 'a
-> FStar.All.ML (Prims.list 'b) | {
"end_col": 30,
"end_line": 280,
"start_col": 21,
"start_line": 275
} |
FStar.All.ML | val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl | val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = | true | null | false | match l with
| [] -> None
| hd :: tl -> if p hd then Some hd else tryFind p tl | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.List.tryFind"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a) | [
"recursion"
] | FStar.List.tryFind | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: (_: 'a -> FStar.All.ML Prims.bool) -> l: Prims.list 'a
-> FStar.All.ML (FStar.Pervasives.Native.option 'a) | {
"end_col": 54,
"end_line": 256,
"start_col": 22,
"start_line": 254
} |
FStar.All.ML | val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2 | val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = | true | null | false | function
| [] -> [], []
| hd :: tl ->
let l1, l2 = partition f tl in
if f hd then hd :: l1, l2 else l1, hd :: l2 | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"Prims.bool",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"Prims.Cons",
"FStar.List.partition"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *) | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a) | [
"recursion"
] | FStar.List.partition | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML Prims.bool) -> _: Prims.list 'a
-> FStar.All.ML (Prims.list 'a * Prims.list 'a) | {
"end_col": 20,
"end_line": 294,
"start_col": 22,
"start_line": 288
} |
FStar.All.ML | val filter_map (f: ('a -> ML (option 'b))) (l: list 'a) : ML (list 'b) | [
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let filter_map (f:'a -> ML (option 'b)) (l:list 'a) : ML (list 'b) =
let rec filter_map_acc (acc:list 'b) (l:list 'a) : ML (list 'b) =
match l with
| [] ->
rev acc
| hd :: tl ->
match f hd with
| Some hd ->
filter_map_acc (hd :: acc) tl
| None ->
filter_map_acc acc tl
in
filter_map_acc [] l | val filter_map (f: ('a -> ML (option 'b))) (l: list 'a) : ML (list 'b)
let filter_map (f: ('a -> ML (option 'b))) (l: list 'a) : ML (list 'b) = | true | null | false | let rec filter_map_acc (acc: list 'b) (l: list 'a) : ML (list 'b) =
match l with
| [] -> rev acc
| hd :: tl ->
match f hd with
| Some hd -> filter_map_acc (hd :: acc) tl
| None -> filter_map_acc acc tl
in
filter_map_acc [] l | {
"checked_file": "FStar.List.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "FStar.List.fst"
} | [
"ml"
] | [
"FStar.Pervasives.Native.option",
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.rev",
"Prims.Cons"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
F* standard library List module.
@summary F* stdlib List module.
*)
module FStar.List
open FStar.All
include FStar.List.Tot
(** Base operations **)
(** [hd l] returns the first element of [l]. Raises an exception if
[l] is empty (thus, [hd] hides [List.Tot.hd] which requires [l] to be
nonempty at type-checking time.) Named as in: OCaml, F#, Coq *)
val hd: list 'a -> ML 'a
let hd = function
| hd::tl -> hd
| _ -> failwith "head of empty list"
(** [tail l] returns [l] without its first element. Raises an
exception if [l] is empty (thus, [tail] hides [List.Tot.tail] which
requires [l] to be nonempty at type-checking time). Similar to: tl in
OCaml, F#, Coq *)
val tail: list 'a -> ML (list 'a)
let tail = function
| hd::tl -> tl
| _ -> failwith "tail of empty list"
(** [tl l] returns [l] without its first element. Raises an exception
if [l] is empty (thus, [tl] hides [List.Tot.tl] which requires [l] to
be nonempty at type-checking time). Named as in: tl in OCaml, F#, Coq
*)
val tl : list 'a -> ML (list 'a)
let tl l = tail l
(** [last l] returns the last element of [l]. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val last: list 'a -> ML 'a
let rec last = function
| [hd] -> hd
| _::tl -> last tl
| _ -> failwith "last of empty list"
(** [init l] returns [l] without its last element. Requires, at
type-checking time, that [l] be nonempty. Named as in: Haskell
*)
val init: list 'a -> ML (list 'a)
let rec init = function
| [_] -> []
| hd::tl -> hd::(init tl)
| _ -> failwith "init of empty list"
(** [nth l n] returns the [n]-th element in list [l] (with the first
element being the 0-th) if [l] is long enough, or raises an exception
otherwise (thus, [nth] hides [List.Tot.nth] which has [option] type.)
Named as in: OCaml, F#, Coq *)
val nth: list 'a -> int -> ML 'a
let rec nth l n =
if n < 0 then
failwith "nth takes a non-negative integer as input"
else
if n = 0 then
match l with
| [] -> failwith "not enough elements"
| hd::_ -> hd
else
match l with
| [] -> failwith "not enough elements"
| _::tl -> nth tl (n - 1)
(** Iterators **)
(** [iter f l] performs [f x] for each element [x] of [l], in the
order in which they appear in [l]. Named as in: OCaml, F# . *)
val iter: ('a -> ML unit) -> list 'a -> ML unit
let rec iter f x = match x with
| [] -> ()
| a::tl -> let _ = f a in iter f tl
(** [iteri_aux n f l] performs, for each i, [f (i+n) x] for the i-th
element [x] of [l], in the order in which they appear in [l]. *)
val iteri_aux: int -> (int -> 'a -> ML unit) -> list 'a -> ML unit
let rec iteri_aux i f x = match x with
| [] -> ()
| a::tl -> f i a; iteri_aux (i+1) f tl
(** [iteri_aux f l] performs, for each [i], [f i x] for the i-th
element [x] of [l], in the order in which they appear in [l]. Named as
in: OCaml *)
val iteri: (int -> 'a -> ML unit) -> list 'a -> ML unit
let iteri f x = iteri_aux 0 f x
(** [map f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. (Hides
[List.Tot.map] which requires, at type-checking time, [f] to be a pure
total function.) Named as in: OCaml, Coq, F# *)
val map: ('a -> ML 'b) -> list 'a -> ML (list 'b)
let rec map f x = match x with
| [] -> []
| a::tl -> f a::map f tl
(** [mapT f l] applies [f] to each element of [l] and returns the list
of results, in the order of the original elements in [l]. Requires, at
type-checking time, [f] to be a pure total function. *)
val mapT: ('a -> Tot 'b) -> list 'a -> Tot (list 'b)
let mapT = FStar.List.Tot.map
(** [mapi_init f n l] applies, for each [k], [f (n+k)] to the [k]-th
element of [l] and returns the list of results, in the order of the
original elements in [l]. (Hides [List.Tot.mapi_init] which requires,
at type-checking time, [f] to be a pure total function.) *)
val mapi_init: (int -> 'a -> ML 'b) -> list 'a -> int -> ML (list 'b)
let rec mapi_init f l i = match l with
| [] -> []
| hd::tl -> (f i hd)::(mapi_init f tl (i+1))
(** [mapi f l] applies, for each [k], [f k] to the [k]-th element of
[l] and returns the list of results, in the order of the original
elements in [l]. (Hides [List.Tot.mapi] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml *)
val mapi: (int -> 'a -> ML 'b) -> list 'a -> ML (list 'b)
let mapi f l = mapi_init f l 0
(** [concatMap f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. This is equivalent to [flatten (map f l)]. (Hides
[List.Tot.concatMap], which requires, at type-checking time, [f] to be
a pure total function.) *)
val concatMap: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec concatMap f = function
| [] -> []
| a::tl ->
let fa = f a in
let ftl = concatMap f tl in
fa @ ftl
(** [map2 f l1 l2] computes [f x1 x2] for each element x1 of [l1] and
the element [x2] of [l2] at the same position, and returns the list of
such results, in the order of the original elements in [l1]. Raises an
exception if [l1] and [l2] have different lengths. Named as in: OCaml
*)
val map2: ('a -> 'b -> ML 'c) -> list 'a -> list 'b -> ML (list 'c)
let rec map2 f l1 l2 = match l1, l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (f hd1 hd2)::(map2 f tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** [map3 f l1 l2 l3] computes [f x1 x2 x3] for each element x1 of
[l1] and the element [x2] of [l2] and the element [x3] of [l3] at the
same position, and returns the list of such results, in the order of
the original elements in [l1]. Raises an exception if [l1], [l2] and
[l3] have different lengths. Named as in: OCaml *)
val map3: ('a -> 'b -> 'c -> ML 'd) -> list 'a -> list 'b -> list 'c -> ML (list 'd)
let rec map3 f l1 l2 l3 = match l1, l2, l3 with
| [], [], [] -> []
| hd1::tl1, hd2::tl2, hd3::tl3 -> (f hd1 hd2 hd3)::(map3 f tl1 tl2 tl3)
| _, _, _ -> failwith "The lists do not have the same length"
(** [fold_left f x [y1; y2; ...; yn]] computes (f (... (f x y1) y2)
... yn). (Hides [List.Tot.fold_left], which requires, at type-checking
time, [f] to be a pure total function.) Named as in: OCaml, Coq *)
val fold_left: ('a -> 'b -> ML 'a) -> 'a -> list 'b -> ML 'a
let rec fold_left f x y = match y with
| [] -> x
| hd::tl -> fold_left f (f x hd) tl
(** [fold_left2 f x [y1; y2; ...; yn] [z1; z2; ...; zn]] computes (f
(... (f x y1 z1) y2 z2 ... yn zn). Raises an exception if [y1; y2;
...] and [z1; z2; ...] have different lengths. (Thus, hides
[List.Tot.fold_left2] which requires such a condition at type-checking
time.) Named as in: OCaml *)
val fold_left2: ('s -> 'a -> 'b -> ML 's) -> 's -> list 'a -> list 'b -> ML 's
let rec fold_left2 f a l1 l2 = match l1, l2 with
| [], [] -> a
| hd1::tl1, hd2::tl2 -> fold_left2 f (f a hd1 hd2) tl1 tl2
| _, _ -> failwith "The lists do not have the same length"
(** [fold_right f [x1; x2; ...; xn] y] computes (f x1 (f x2 (... (f xn
y)) ... )). (Hides [List.Tot.fold_right], which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val fold_right: ('a -> 'b -> ML 'b) -> list 'a -> 'b -> ML 'b
let rec fold_right f l x = match l with
| [] -> x
| hd::tl -> f hd (fold_right f tl x)
(** List searching **)
(** [filter f l] returns [l] with all elements [x] such that [f x]
does not hold removed. (Hides [List.Tot.filter] which requires, at
type-checking time, [f] to be a pure total function.) Named as in:
OCaml, Coq *)
val filter: ('a -> ML bool) -> list 'a -> ML (list 'a)
let rec filter f = function
| [] -> []
| hd::tl -> if f hd then hd::(filter f tl) else filter f tl
(** [for_all f l] returns [true] if, and only if, for all elements [x]
appearing in [l], [f x] holds. (Hides [List.Tot.for_all], which
requires, at type-checking time, [f] to be a pure total function.)
Named as in: OCaml. Similar to: List.forallb in Coq *)
val for_all: ('a -> ML bool) -> list 'a -> ML bool
let rec for_all f l = match l with
| [] -> true
| hd::tl -> if f hd then for_all f tl else false
(** [for_all f l1 l2] returns [true] if, and only if, for all elements
[x1] appearing in [l1] and the element [x2] appearing in [l2] at the
same position, [f x1 x2] holds. Raises an exception if [l1] and [l2]
have different lengths. Similar to: List.for_all2 in OCaml. Similar
to: List.Forall2 in Coq (which is propositional) *)
val forall2: ('a -> 'b -> ML bool) -> list 'a -> list 'b -> ML bool
let rec forall2 f l1 l2 = match l1,l2 with
| [], [] -> true
| hd1::tl1, hd2::tl2 -> if f hd1 hd2 then forall2 f tl1 tl2 else false
| _, _ -> failwith "The lists do not have the same length"
(** [collect f l] applies [f] to each element of [l] and returns the
concatenation of the results, in the order of the original elements of
[l]. It is equivalent to [flatten (map f l)]. (Hides
[List.Tot.collect] which requires, at type-checking time, [f] to be a
pure total function.) TODO: what is the difference with [concatMap]?
*)
val collect: ('a -> ML (list 'b)) -> list 'a -> ML (list 'b)
let rec collect f l = match l with
| [] -> []
| hd::tl -> append (f hd) (collect f tl)
(** [tryFind f l] returns [Some x] for some element [x] appearing in
[l] such that [f x] holds, or [None] only if no such [x]
exists. (Hides [List.Tot.tryFind], which requires, at type-checking
time, [f] to be a pure total function.) *)
val tryFind: ('a -> ML bool) -> list 'a -> ML (option 'a)
let rec tryFind p l = match l with
| [] -> None
| hd::tl -> if p hd then Some hd else tryFind p tl
(** [tryPick f l] returns [y] for some element [x] appearing in [l]
such that [f x = Some y] for some y, or [None] only if [f x = None]
for all elements [x] of [l]. (Hides [List.Tot.tryPick], which
requires, at type-checking time, [f] to be a pure total function.) *)
val tryPick: ('a -> ML (option 'b)) -> list 'a -> ML (option 'b)
let rec tryPick f l = match l with
| [] -> None
| hd::tl ->
match f hd with
| Some x -> Some x
| None -> tryPick f tl
(** [choose f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Hides
[List.Tot.choose] which requires, at type-checking time, [f] to be a
pure total function.) *)
val choose: ('a -> ML (option 'b)) -> list 'a -> ML (list 'b)
let rec choose f l = match l with
| [] -> []
| hd::tl ->
match f hd with
| Some x -> x::(choose f tl)
| None -> choose f tl
(** [partition f l] returns the pair of lists [(l1, l2)] where all
elements [x] of [l] are in [l1] if [f x] holds, and in [l2]
otherwise. Both [l1] and [l2] retain the original order of [l]. (Hides
[List.Tot.partition], which requires, at type-checking time, [f] to be
a pure total function.) *)
val partition: ('a -> ML bool) -> list 'a -> ML (list 'a * list 'a)
let rec partition f = function
| [] -> [], []
| hd::tl ->
let l1, l2 = partition f tl in
if f hd
then hd::l1, l2
else l1, hd::l2
(** List of tuples **)
(** [zip] takes two lists [x1, ..., xn] and [y1, ..., yn] and returns
the list of pairs [(x1, y1), ..., (xn, yn)]. Raises an exception if
the two lists have different lengths. Named as in: Haskell *)
val zip: list 'a -> list 'b -> ML (list ('a * 'b))
let rec zip l1 l2 = match l1,l2 with
| [], [] -> []
| hd1::tl1, hd2::tl2 -> (hd1,hd2)::(zip tl1 tl2)
| _, _ -> failwith "The lists do not have the same length"
(** Sorting (implemented as quicksort) **)
(** [sortWith compare l] returns the list [l'] containing the elements
of [l] sorted along the comparison function [compare], in such a way
that if [compare x y > 0], then [x] appears before [y] in [l']. (Hides
[List.Tot.sortWith], which requires, at type-checking time, [compare]
to be a pure total function.) *)
val sortWith: ('a -> 'a -> ML int) -> list 'a -> ML (list 'a)
let rec sortWith f = function
| [] -> []
| pivot::tl ->
let hi, lo = partition (fun x -> f pivot x > 0) tl in
sortWith f lo@(pivot::sortWith f hi)
(** [splitAt n l] returns the pair of lists [(l1, l2)] such that [l1]
contains the first [n] elements of [l] and [l2] contains the
rest. Raises an exception if [l] has fewer than [n] elements. *)
val splitAt: nat -> list 'a -> ML (list 'a * list 'a)
let rec splitAt n l =
if n = 0 then [], l
else
match l with
| [] -> failwith "splitAt index is more that list length"
| hd::tl ->
let l1, l2 = splitAt (n - 1) tl in
hd::l1, l2
(** [filter_map f l] returns the list of [y] for all elements [x]
appearing in [l] such that [f x = Some y] for some [y]. (Implemented | false | false | FStar.List.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val filter_map (f: ('a -> ML (option 'b))) (l: list 'a) : ML (list 'b) | [] | FStar.List.filter_map | {
"file_name": "ulib/FStar.List.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: 'a -> FStar.All.ML (FStar.Pervasives.Native.option 'b)) -> l: Prims.list 'a
-> FStar.All.ML (Prims.list 'b) | {
"end_col": 21,
"end_line": 349,
"start_col": 68,
"start_line": 337
} |
Prims.Tot | val tag1_len:(x: UInt32.t{UInt32.v x = B.length tag1}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul | val tag1_len:(x: UInt32.t{UInt32.v x = B.length tag1})
let tag1_len:(x: UInt32.t{UInt32.v x = B.length tag1}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag1_len:(x: UInt32.t{UInt32.v x = B.length tag1}) | [] | Test.Vectors.Poly1305.tag1_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag1} | {
"end_col": 6,
"end_line": 53,
"start_col": 2,
"start_line": 53
} |
Prims.Tot | val key4_len:(x: UInt32.t{UInt32.v x = B.length key4}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul | val key4_len:(x: UInt32.t{UInt32.v x = B.length key4})
let key4_len:(x: UInt32.t{UInt32.v x = B.length key4}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key4_len:(x: UInt32.t{UInt32.v x = B.length key4}) | [] | Test.Vectors.Poly1305.key4_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key4} | {
"end_col": 6,
"end_line": 117,
"start_col": 2,
"start_line": 117
} |
Prims.Tot | val input0:(b: B.buffer UInt8.t {B.length b = 34 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l | val input0:(b: B.buffer UInt8.t {B.length b = 34 /\ B.recallable b})
let input0:(b: B.buffer UInt8.t {B.length b = 34 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy;
0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy;
0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy
]
in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0" | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input0:(b: B.buffer UInt8.t {B.length b = 34 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input0 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 34 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 10,
"start_col": 2,
"start_line": 8
} |
Prims.Tot | val input1:(b: B.buffer UInt8.t {B.length b = 2 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l | val input1:(b: B.buffer UInt8.t {B.length b = 2 /\ B.recallable b})
let input1:(b: B.buffer UInt8.t {B.length b = 2 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l = [0xf3uy; 0xf6uy] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input1:(b: B.buffer UInt8.t {B.length b = 2 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input1 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 2 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 34,
"start_col": 2,
"start_line": 32
} |
Prims.Tot | val tag2_len:(x: UInt32.t{UInt32.v x = B.length tag2}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul | val tag2_len:(x: UInt32.t{UInt32.v x = B.length tag2})
let tag2_len:(x: UInt32.t{UInt32.v x = B.length tag2}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag2_len:(x: UInt32.t{UInt32.v x = B.length tag2}) | [] | Test.Vectors.Poly1305.tag2_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag2} | {
"end_col": 6,
"end_line": 77,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val input2_len:(x: UInt32.t{UInt32.v x = B.length input2}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul | val input2_len:(x: UInt32.t{UInt32.v x = B.length input2})
let input2_len:(x: UInt32.t{UInt32.v x = B.length input2}) = | false | null | false | 0ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input2_len:(x: UInt32.t{UInt32.v x = B.length input2}) | [] | Test.Vectors.Poly1305.input2_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input2} | {
"end_col": 5,
"end_line": 61,
"start_col": 2,
"start_line": 61
} |
Prims.Tot | val key6:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key6:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key6:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy;
0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy;
0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key6:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key6 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 162,
"start_col": 2,
"start_line": 160
} |
Prims.Tot | val tag7_len:(x: UInt32.t{UInt32.v x = B.length tag7}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul | val tag7_len:(x: UInt32.t{UInt32.v x = B.length tag7})
let tag7_len:(x: UInt32.t{UInt32.v x = B.length tag7}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag7_len:(x: UInt32.t{UInt32.v x = B.length tag7}) | [] | Test.Vectors.Poly1305.tag7_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag7} | {
"end_col": 6,
"end_line": 197,
"start_col": 2,
"start_line": 197
} |
Prims.Tot | val key11_len:(x: UInt32.t{UInt32.v x = B.length key11}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul | val key11_len:(x: UInt32.t{UInt32.v x = B.length key11})
let key11_len:(x: UInt32.t{UInt32.v x = B.length key11}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key11_len:(x: UInt32.t{UInt32.v x = B.length key11}) | [] | Test.Vectors.Poly1305.key11_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key11} | {
"end_col": 6,
"end_line": 285,
"start_col": 2,
"start_line": 285
} |
Prims.Tot | val input11_len:(x: UInt32.t{UInt32.v x = B.length input11}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul | val input11_len:(x: UInt32.t{UInt32.v x = B.length input11})
let input11_len:(x: UInt32.t{UInt32.v x = B.length input11}) = | false | null | false | 160ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input11_len:(x: UInt32.t{UInt32.v x = B.length input11}) | [] | Test.Vectors.Poly1305.input11_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input11} | {
"end_col": 7,
"end_line": 277,
"start_col": 2,
"start_line": 277
} |
Prims.Tot | val input6_len:(x: UInt32.t{UInt32.v x = B.length input6}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul | val input6_len:(x: UInt32.t{UInt32.v x = B.length input6})
let input6_len:(x: UInt32.t{UInt32.v x = B.length input6}) = | false | null | false | 48ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input6_len:(x: UInt32.t{UInt32.v x = B.length input6}) | [] | Test.Vectors.Poly1305.input6_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input6} | {
"end_col": 6,
"end_line": 157,
"start_col": 2,
"start_line": 157
} |
Prims.Tot | val key4:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key4:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key4:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy;
0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy;
0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key4:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key4 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 114,
"start_col": 2,
"start_line": 112
} |
Prims.Tot | val key9:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key9:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key9:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy;
0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy;
0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key9:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key9 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 234,
"start_col": 2,
"start_line": 232
} |
Prims.Tot | val tag5:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag5:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag5:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy;
0x31uy; 0xbeuy; 0xe4uy; 0x66uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag5:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag5 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 146,
"start_col": 2,
"start_line": 144
} |
Prims.Tot | val key10:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key10:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key10:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy;
0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy;
0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key10:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key10 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 258,
"start_col": 2,
"start_line": 256
} |
Prims.Tot | val key15_len:(x: UInt32.t{UInt32.v x = B.length key15}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul | val key15_len:(x: UInt32.t{UInt32.v x = B.length key15})
let key15_len:(x: UInt32.t{UInt32.v x = B.length key15}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key15_len:(x: UInt32.t{UInt32.v x = B.length key15}) | [] | Test.Vectors.Poly1305.key15_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key15} | {
"end_col": 6,
"end_line": 381,
"start_col": 2,
"start_line": 381
} |
Prims.Tot | val key18_len:(x: UInt32.t{UInt32.v x = B.length key18}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul | val key18_len:(x: UInt32.t{UInt32.v x = B.length key18})
let key18_len:(x: UInt32.t{UInt32.v x = B.length key18}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key18_len:(x: UInt32.t{UInt32.v x = B.length key18}) | [] | Test.Vectors.Poly1305.key18_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key18} | {
"end_col": 6,
"end_line": 453,
"start_col": 2,
"start_line": 453
} |
Prims.Tot | val tag19_len:(x: UInt32.t{UInt32.v x = B.length tag19}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul | val tag19_len:(x: UInt32.t{UInt32.v x = B.length tag19})
let tag19_len:(x: UInt32.t{UInt32.v x = B.length tag19}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag19_len:(x: UInt32.t{UInt32.v x = B.length tag19}) | [] | Test.Vectors.Poly1305.tag19_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag19} | {
"end_col": 6,
"end_line": 485,
"start_col": 2,
"start_line": 485
} |
Prims.Tot | val tag9_len:(x: UInt32.t{UInt32.v x = B.length tag9}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul | val tag9_len:(x: UInt32.t{UInt32.v x = B.length tag9})
let tag9_len:(x: UInt32.t{UInt32.v x = B.length tag9}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag9_len:(x: UInt32.t{UInt32.v x = B.length tag9}) | [] | Test.Vectors.Poly1305.tag9_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag9} | {
"end_col": 6,
"end_line": 245,
"start_col": 2,
"start_line": 245
} |
Prims.Tot | val key10_len:(x: UInt32.t{UInt32.v x = B.length key10}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul | val key10_len:(x: UInt32.t{UInt32.v x = B.length key10})
let key10_len:(x: UInt32.t{UInt32.v x = B.length key10}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key10_len:(x: UInt32.t{UInt32.v x = B.length key10}) | [] | Test.Vectors.Poly1305.key10_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key10} | {
"end_col": 6,
"end_line": 261,
"start_col": 2,
"start_line": 261
} |
Prims.Tot | val input10_len:(x: UInt32.t{UInt32.v x = B.length input10}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul | val input10_len:(x: UInt32.t{UInt32.v x = B.length input10})
let input10_len:(x: UInt32.t{UInt32.v x = B.length input10}) = | false | null | false | 144ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input10_len:(x: UInt32.t{UInt32.v x = B.length input10}) | [] | Test.Vectors.Poly1305.input10_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input10} | {
"end_col": 7,
"end_line": 253,
"start_col": 2,
"start_line": 253
} |
Prims.Tot | val tag14_len:(x: UInt32.t{UInt32.v x = B.length tag14}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul | val tag14_len:(x: UInt32.t{UInt32.v x = B.length tag14})
let tag14_len:(x: UInt32.t{UInt32.v x = B.length tag14}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag14_len:(x: UInt32.t{UInt32.v x = B.length tag14}) | [] | Test.Vectors.Poly1305.tag14_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag14} | {
"end_col": 6,
"end_line": 365,
"start_col": 2,
"start_line": 365
} |
Prims.Tot | val key13_len:(x: UInt32.t{UInt32.v x = B.length key13}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul | val key13_len:(x: UInt32.t{UInt32.v x = B.length key13})
let key13_len:(x: UInt32.t{UInt32.v x = B.length key13}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key13_len:(x: UInt32.t{UInt32.v x = B.length key13}) | [] | Test.Vectors.Poly1305.key13_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key13} | {
"end_col": 6,
"end_line": 333,
"start_col": 2,
"start_line": 333
} |
Prims.Tot | val key19:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key19:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key19:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy;
0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy;
0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key19:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key19 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 474,
"start_col": 2,
"start_line": 472
} |
Prims.Tot | val input26_len:(x: UInt32.t{UInt32.v x = B.length input26}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul | val input26_len:(x: UInt32.t{UInt32.v x = B.length input26})
let input26_len:(x: UInt32.t{UInt32.v x = B.length input26}) = | false | null | false | 118ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input26_len:(x: UInt32.t{UInt32.v x = B.length input26}) | [] | Test.Vectors.Poly1305.input26_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input26} | {
"end_col": 7,
"end_line": 637,
"start_col": 2,
"start_line": 637
} |
Prims.Tot | val tag21:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag21:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag21:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy;
0x42uy; 0x5euy; 0x28uy; 0x20uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag21:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag21 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 530,
"start_col": 2,
"start_line": 528
} |
Prims.Tot | val key17:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key17:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key17:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy;
0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy;
0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key17:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key17 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 426,
"start_col": 2,
"start_line": 424
} |
Prims.Tot | val key25_len:(x: UInt32.t{UInt32.v x = B.length key25}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul | val key25_len:(x: UInt32.t{UInt32.v x = B.length key25})
let key25_len:(x: UInt32.t{UInt32.v x = B.length key25}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key25_len:(x: UInt32.t{UInt32.v x = B.length key25}) | [] | Test.Vectors.Poly1305.key25_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key25} | {
"end_col": 6,
"end_line": 621,
"start_col": 2,
"start_line": 621
} |
Prims.Tot | val tag20:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag20:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag20:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy;
0x4cuy; 0x7buy; 0xcduy; 0x51uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag20:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag20 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 506,
"start_col": 2,
"start_line": 504
} |
Prims.Tot | val tag21_len:(x: UInt32.t{UInt32.v x = B.length tag21}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul | val tag21_len:(x: UInt32.t{UInt32.v x = B.length tag21})
let tag21_len:(x: UInt32.t{UInt32.v x = B.length tag21}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag21_len:(x: UInt32.t{UInt32.v x = B.length tag21}) | [] | Test.Vectors.Poly1305.tag21_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag21} | {
"end_col": 6,
"end_line": 533,
"start_col": 2,
"start_line": 533
} |
Prims.Tot | val tag26_len:(x: UInt32.t{UInt32.v x = B.length tag26}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul | val tag26_len:(x: UInt32.t{UInt32.v x = B.length tag26})
let tag26_len:(x: UInt32.t{UInt32.v x = B.length tag26}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag26_len:(x: UInt32.t{UInt32.v x = B.length tag26}) | [] | Test.Vectors.Poly1305.tag26_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag26} | {
"end_col": 6,
"end_line": 653,
"start_col": 2,
"start_line": 653
} |
Prims.Tot | val key20:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key20:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key20:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy;
0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy;
0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key20:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key20 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 498,
"start_col": 2,
"start_line": 496
} |
Prims.Tot | val key26:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key26:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key26:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy;
0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key26:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key26 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 642,
"start_col": 2,
"start_line": 640
} |
Prims.Tot | val key27:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key27:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key27:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy;
0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy;
0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key27:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key27 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 666,
"start_col": 2,
"start_line": 664
} |
Prims.Tot | val input29_len:(x: UInt32.t{UInt32.v x = B.length input29}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul | val input29_len:(x: UInt32.t{UInt32.v x = B.length input29})
let input29_len:(x: UInt32.t{UInt32.v x = B.length input29}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input29_len:(x: UInt32.t{UInt32.v x = B.length input29}) | [] | Test.Vectors.Poly1305.input29_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input29} | {
"end_col": 6,
"end_line": 709,
"start_col": 2,
"start_line": 709
} |
Prims.Tot | val input30_len:(x: UInt32.t{UInt32.v x = B.length input30}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul | val input30_len:(x: UInt32.t{UInt32.v x = B.length input30})
let input30_len:(x: UInt32.t{UInt32.v x = B.length input30}) = | false | null | false | 48ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input30_len:(x: UInt32.t{UInt32.v x = B.length input30}) | [] | Test.Vectors.Poly1305.input30_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input30} | {
"end_col": 6,
"end_line": 733,
"start_col": 2,
"start_line": 733
} |
Prims.Tot | val tag32_len:(x: UInt32.t{UInt32.v x = B.length tag32}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul | val tag32_len:(x: UInt32.t{UInt32.v x = B.length tag32})
let tag32_len:(x: UInt32.t{UInt32.v x = B.length tag32}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag32_len:(x: UInt32.t{UInt32.v x = B.length tag32}) | [] | Test.Vectors.Poly1305.tag32_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag32} | {
"end_col": 6,
"end_line": 797,
"start_col": 2,
"start_line": 797
} |
Prims.Tot | val tag34:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag34: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag34:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag34:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul
let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input33_len: (x:UInt32.t { UInt32.v x = B.length input33 }) =
64ul
let key33: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key33_len: (x:UInt32.t { UInt32.v x = B.length key33 }) =
32ul
let tag33: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x55uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag33_len: (x:UInt32.t { UInt32.v x = B.length tag33 }) =
16ul
let input34: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input34_len: (x:UInt32.t { UInt32.v x = B.length input34 }) =
48ul
let key34: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key34_len: (x:UInt32.t { UInt32.v x = B.length key34 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag34:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag34 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 842,
"start_col": 2,
"start_line": 840
} |
Prims.Tot | val input28_len:(x: UInt32.t{UInt32.v x = B.length input28}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul | val input28_len:(x: UInt32.t{UInt32.v x = B.length input28})
let input28_len:(x: UInt32.t{UInt32.v x = B.length input28}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input28_len:(x: UInt32.t{UInt32.v x = B.length input28}) | [] | Test.Vectors.Poly1305.input28_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input28} | {
"end_col": 6,
"end_line": 685,
"start_col": 2,
"start_line": 685
} |
Prims.Tot | val tag32:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag32:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag32:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0xffuy; 0xffuy; 0xffuy; 0xffuy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag32:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag32 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 794,
"start_col": 2,
"start_line": 792
} |
Prims.Tot | val tag31:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag31:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag31:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag31:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag31 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 770,
"start_col": 2,
"start_line": 768
} |
Prims.Tot | val key34:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key34: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key34:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key34:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul
let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input33_len: (x:UInt32.t { UInt32.v x = B.length input33 }) =
64ul
let key33: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key33_len: (x:UInt32.t { UInt32.v x = B.length key33 }) =
32ul
let tag33: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x55uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag33_len: (x:UInt32.t { UInt32.v x = B.length tag33 }) =
16ul
let input34: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input34_len: (x:UInt32.t { UInt32.v x = B.length input34 }) =
48ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key34:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key34 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 834,
"start_col": 2,
"start_line": 832
} |
Prims.Tot | val key30_len:(x: UInt32.t{UInt32.v x = B.length key30}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul | val key30_len:(x: UInt32.t{UInt32.v x = B.length key30})
let key30_len:(x: UInt32.t{UInt32.v x = B.length key30}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key30_len:(x: UInt32.t{UInt32.v x = B.length key30}) | [] | Test.Vectors.Poly1305.key30_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key30} | {
"end_col": 6,
"end_line": 741,
"start_col": 2,
"start_line": 741
} |
Prims.Tot | val key33:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key33: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key33:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key33:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul
let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input33_len: (x:UInt32.t { UInt32.v x = B.length input33 }) =
64ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key33:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key33 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 810,
"start_col": 2,
"start_line": 808
} |
Prims.Tot | val input31:(b: B.buffer UInt8.t {B.length b = 48 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l | val input31:(b: B.buffer UInt8.t {B.length b = 48 /\ B.recallable b})
let input31:(b: B.buffer UInt8.t {B.length b = 48 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy;
0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy;
0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy;
0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy
]
in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input31:(b: B.buffer UInt8.t {B.length b = 48 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input31 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 48 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 754,
"start_col": 2,
"start_line": 752
} |
Prims.Tot | val tag33_len:(x: UInt32.t{UInt32.v x = B.length tag33}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag33_len: (x:UInt32.t { UInt32.v x = B.length tag33 }) =
16ul | val tag33_len:(x: UInt32.t{UInt32.v x = B.length tag33})
let tag33_len:(x: UInt32.t{UInt32.v x = B.length tag33}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul
let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input33_len: (x:UInt32.t { UInt32.v x = B.length input33 }) =
64ul
let key33: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key33_len: (x:UInt32.t { UInt32.v x = B.length key33 }) =
32ul
let tag33: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x55uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag33_len:(x: UInt32.t{UInt32.v x = B.length tag33}) | [] | Test.Vectors.Poly1305.tag33_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag33} | {
"end_col": 6,
"end_line": 821,
"start_col": 2,
"start_line": 821
} |
Prims.Tot | val tag34_len:(x: UInt32.t{UInt32.v x = B.length tag34}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag34_len: (x:UInt32.t { UInt32.v x = B.length tag34 }) =
16ul | val tag34_len:(x: UInt32.t{UInt32.v x = B.length tag34})
let tag34_len:(x: UInt32.t{UInt32.v x = B.length tag34}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul
let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input33_len: (x:UInt32.t { UInt32.v x = B.length input33 }) =
64ul
let key33: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key33_len: (x:UInt32.t { UInt32.v x = B.length key33 }) =
32ul
let tag33: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x55uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag33_len: (x:UInt32.t { UInt32.v x = B.length tag33 }) =
16ul
let input34: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input34_len: (x:UInt32.t { UInt32.v x = B.length input34 }) =
48ul
let key34: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x04uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key34_len: (x:UInt32.t { UInt32.v x = B.length key34 }) =
32ul
let tag34: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag34_len:(x: UInt32.t{UInt32.v x = B.length tag34}) | [] | Test.Vectors.Poly1305.tag34_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag34} | {
"end_col": 6,
"end_line": 845,
"start_col": 2,
"start_line": 845
} |
Prims.Tot | val input33:(b: B.buffer UInt8.t {B.length b = 64 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input33: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l | val input33:(b: B.buffer UInt8.t {B.length b = 64 /\ B.recallable b})
let input33:(b: B.buffer UInt8.t {B.length b = 64 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xe3uy; 0x35uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0xb9uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x33uy; 0x94uy; 0xd7uy; 0x50uy; 0x5euy; 0x43uy; 0x79uy; 0xcduy;
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy;
0x00uy; 0x00uy; 0x00uy; 0x00uy
]
in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul
let input5: (b: B.buffer UInt8.t { B.length b = 64 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; ] in
assert_norm (List.Tot.length l = 64);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
64ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let tag5: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag5_len: (x:UInt32.t { UInt32.v x = B.length tag5 }) =
16ul
let input6: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
48ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let tag6: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag6_len: (x:UInt32.t { UInt32.v x = B.length tag6 }) =
16ul
let input7: (b: B.buffer UInt8.t { B.length b = 96 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 96);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
96ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let tag7: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbbuy; 0xb6uy; 0x13uy; 0xb2uy; 0xb6uy; 0xd7uy; 0x53uy; 0xbauy; 0x07uy; 0x39uy; 0x5buy; 0x91uy; 0x6auy; 0xaeuy; 0xceuy; 0x15uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag7_len: (x:UInt32.t { UInt32.v x = B.length tag7 }) =
16ul
let input8: (b: B.buffer UInt8.t { B.length b = 112 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; ] in
assert_norm (List.Tot.length l = 112);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
112ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let tag8: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc7uy; 0x94uy; 0xd7uy; 0x05uy; 0x7duy; 0x17uy; 0x78uy; 0xc4uy; 0xbbuy; 0xeeuy; 0x0auy; 0x39uy; 0xb3uy; 0xd9uy; 0x73uy; 0x42uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag8_len: (x:UInt32.t { UInt32.v x = B.length tag8 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
128ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let tag9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xbcuy; 0xb9uy; 0xb3uy; 0x71uy; 0x42uy; 0x31uy; 0x52uy; 0xd7uy; 0xfcuy; 0xa5uy; 0xaduy; 0x04uy; 0x2fuy; 0xbauy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag9_len: (x:UInt32.t { UInt32.v x = B.length tag9 }) =
16ul
let input10: (b: B.buffer UInt8.t { B.length b = 144 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 144);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
144ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let tag10: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x9euy; 0xd6uy; 0xb8uy; 0xefuy; 0x0fuy; 0x20uy; 0x7buy; 0x3euy; 0x24uy; 0x3buy; 0xb1uy; 0x01uy; 0x9fuy; 0xe6uy; 0x32uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag10_len: (x:UInt32.t { UInt32.v x = B.length tag10 }) =
16ul
let input11: (b: B.buffer UInt8.t { B.length b = 160 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 160);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input11_len: (x:UInt32.t { UInt32.v x = B.length input11 }) =
160ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let tag11: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xa3uy; 0x39uy; 0xd9uy; 0xa4uy; 0x5fuy; 0xa2uy; 0x36uy; 0x8cuy; 0x2cuy; 0x68uy; 0xb3uy; 0xa4uy; 0x17uy; 0x91uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag11_len: (x:UInt32.t { UInt32.v x = B.length tag11 }) =
16ul
let input12: (b: B.buffer UInt8.t { B.length b = 288 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 288);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input12_len: (x:UInt32.t { UInt32.v x = B.length input12 }) =
288ul
let key12: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key12_len: (x:UInt32.t { UInt32.v x = B.length key12 }) =
32ul
let tag12: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x53uy; 0xf6uy; 0xe8uy; 0x28uy; 0xa2uy; 0xf0uy; 0xfeuy; 0x0euy; 0xe8uy; 0x15uy; 0xbfuy; 0x0buy; 0xd5uy; 0x84uy; 0x1auy; 0x34uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag12_len: (x:UInt32.t { UInt32.v x = B.length tag12 }) =
16ul
let input13: (b: B.buffer UInt8.t { B.length b = 320 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; 0xafuy; 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; 0x81uy; 0x20uy; 0x59uy; 0xa5uy; 0xdauy; 0x19uy; 0x86uy; 0x37uy; 0xcauy; 0xc7uy; 0xc4uy; 0xa6uy; 0x31uy; 0xbeuy; 0xe4uy; 0x66uy; 0x5buy; 0x88uy; 0xd7uy; 0xf6uy; 0x22uy; 0x8buy; 0x11uy; 0xe2uy; 0xe2uy; 0x85uy; 0x79uy; 0xa5uy; 0xc0uy; 0xc1uy; 0xf7uy; 0x61uy; ] in
assert_norm (List.Tot.length l = 320);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input13_len: (x:UInt32.t { UInt32.v x = B.length input13 }) =
320ul
let key13: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key13_len: (x:UInt32.t { UInt32.v x = B.length key13 }) =
32ul
let tag13: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb8uy; 0x46uy; 0xd4uy; 0x4euy; 0x9buy; 0xbduy; 0x53uy; 0xceuy; 0xdfuy; 0xfbuy; 0xfbuy; 0xb6uy; 0xb7uy; 0xfauy; 0x49uy; 0x33uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag13_len: (x:UInt32.t { UInt32.v x = B.length tag13 }) =
16ul
let input14: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input14_len: (x:UInt32.t { UInt32.v x = B.length input14 }) =
256ul
let key14: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaduy; 0x62uy; 0x81uy; 0x07uy; 0xe8uy; 0x35uy; 0x1duy; 0x0fuy; 0x2cuy; 0x23uy; 0x1auy; 0x05uy; 0xdcuy; 0x4auy; 0x41uy; 0x06uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key14_len: (x:UInt32.t { UInt32.v x = B.length key14 }) =
32ul
let tag14: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x07uy; 0x14uy; 0x5auy; 0x4cuy; 0x02uy; 0xfeuy; 0x5fuy; 0xa3uy; 0x20uy; 0x36uy; 0xdeuy; 0x68uy; 0xfauy; 0xbeuy; 0x90uy; 0x66uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag14_len: (x:UInt32.t { UInt32.v x = B.length tag14 }) =
16ul
let input15: (b: B.buffer UInt8.t { B.length b = 252 /\ B.recallable b }) =
[@inline_let] let l = [ 0x84uy; 0x23uy; 0x64uy; 0xe1uy; 0x56uy; 0x33uy; 0x6cuy; 0x09uy; 0x98uy; 0xb9uy; 0x33uy; 0xa6uy; 0x23uy; 0x77uy; 0x26uy; 0x18uy; 0x0duy; 0x9euy; 0x3fuy; 0xdcuy; 0xbduy; 0xe4uy; 0xcduy; 0x5duy; 0x17uy; 0x08uy; 0x0fuy; 0xc3uy; 0xbeuy; 0xb4uy; 0x96uy; 0x14uy; 0xd7uy; 0x12uy; 0x2cuy; 0x03uy; 0x74uy; 0x63uy; 0xffuy; 0x10uy; 0x4duy; 0x73uy; 0xf1uy; 0x9cuy; 0x12uy; 0x70uy; 0x46uy; 0x28uy; 0xd4uy; 0x17uy; 0xc4uy; 0xc5uy; 0x4auy; 0x3fuy; 0xe3uy; 0x0duy; 0x3cuy; 0x3duy; 0x77uy; 0x14uy; 0x38uy; 0x2duy; 0x43uy; 0xb0uy; 0x38uy; 0x2auy; 0x50uy; 0xa5uy; 0xdeuy; 0xe5uy; 0x4buy; 0xe8uy; 0x44uy; 0xb0uy; 0x76uy; 0xe8uy; 0xdfuy; 0x88uy; 0x20uy; 0x1auy; 0x1cuy; 0xd4uy; 0x3buy; 0x90uy; 0xebuy; 0x21uy; 0x64uy; 0x3fuy; 0xa9uy; 0x6fuy; 0x39uy; 0xb5uy; 0x18uy; 0xaauy; 0x83uy; 0x40uy; 0xc9uy; 0x42uy; 0xffuy; 0x3cuy; 0x31uy; 0xbauy; 0xf7uy; 0xc9uy; 0xbduy; 0xbfuy; 0x0fuy; 0x31uy; 0xaeuy; 0x3fuy; 0xa0uy; 0x96uy; 0xbfuy; 0x8cuy; 0x63uy; 0x03uy; 0x06uy; 0x09uy; 0x82uy; 0x9fuy; 0xe7uy; 0x2euy; 0x17uy; 0x98uy; 0x24uy; 0x89uy; 0x0buy; 0xc8uy; 0xe0uy; 0x8cuy; 0x31uy; 0x5cuy; 0x1cuy; 0xceuy; 0x2auy; 0x83uy; 0x14uy; 0x4duy; 0xbbuy; 0xffuy; 0x09uy; 0xf7uy; 0x4euy; 0x3euy; 0xfcuy; 0x77uy; 0x0buy; 0x54uy; 0xd0uy; 0x98uy; 0x4auy; 0x8fuy; 0x19uy; 0xb1uy; 0x47uy; 0x19uy; 0xe6uy; 0x36uy; 0x35uy; 0x64uy; 0x1duy; 0x6buy; 0x1euy; 0xeduy; 0xf6uy; 0x3euy; 0xfbuy; 0xf0uy; 0x80uy; 0xe1uy; 0x78uy; 0x3duy; 0x32uy; 0x44uy; 0x54uy; 0x12uy; 0x11uy; 0x4cuy; 0x20uy; 0xdeuy; 0x0buy; 0x83uy; 0x7auy; 0x0duy; 0xfauy; 0x33uy; 0xd6uy; 0xb8uy; 0x28uy; 0x25uy; 0xffuy; 0xf4uy; 0x4cuy; 0x9auy; 0x70uy; 0xeauy; 0x54uy; 0xceuy; 0x47uy; 0xf0uy; 0x7duy; 0xf6uy; 0x98uy; 0xe6uy; 0xb0uy; 0x33uy; 0x23uy; 0xb5uy; 0x30uy; 0x79uy; 0x36uy; 0x4auy; 0x5fuy; 0xc3uy; 0xe9uy; 0xdduy; 0x03uy; 0x43uy; 0x92uy; 0xbduy; 0xdeuy; 0x86uy; 0xdcuy; 0xcduy; 0xdauy; 0x94uy; 0x32uy; 0x1cuy; 0x5euy; 0x44uy; 0x06uy; 0x04uy; 0x89uy; 0x33uy; 0x6cuy; 0xb6uy; 0x5buy; 0xf3uy; 0x98uy; 0x9cuy; 0x36uy; 0xf7uy; 0x28uy; 0x2cuy; 0x2fuy; 0x5duy; 0x2buy; 0x88uy; 0x2cuy; 0x17uy; 0x1euy; 0x74uy; ] in
assert_norm (List.Tot.length l = 252);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input15_len: (x:UInt32.t { UInt32.v x = B.length input15 }) =
252ul
let key15: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x95uy; 0xd5uy; 0xc0uy; 0x05uy; 0x50uy; 0x3euy; 0x51uy; 0x0duy; 0x8cuy; 0xd0uy; 0xaauy; 0x07uy; 0x2cuy; 0x4auy; 0x4duy; 0x06uy; 0x6euy; 0xabuy; 0xc5uy; 0x2duy; 0x11uy; 0x65uy; 0x3duy; 0xf4uy; 0x7fuy; 0xbfuy; 0x63uy; 0xabuy; 0x19uy; 0x8buy; 0xccuy; 0x26uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key15_len: (x:UInt32.t { UInt32.v x = B.length key15 }) =
32ul
let tag15: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0x48uy; 0x31uy; 0x2euy; 0x57uy; 0x8duy; 0x9duy; 0x58uy; 0xf8uy; 0xb7uy; 0xbbuy; 0x4duy; 0x19uy; 0x10uy; 0x54uy; 0x31uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag15_len: (x:UInt32.t { UInt32.v x = B.length tag15 }) =
16ul
let input16: (b: B.buffer UInt8.t { B.length b = 208 /\ B.recallable b }) =
[@inline_let] let l = [ 0x24uy; 0x8auy; 0xc3uy; 0x10uy; 0x85uy; 0xb6uy; 0xc2uy; 0xaduy; 0xaauy; 0xa3uy; 0x82uy; 0x59uy; 0xa0uy; 0xd7uy; 0x19uy; 0x2cuy; 0x5cuy; 0x35uy; 0xd1uy; 0xbbuy; 0x4euy; 0xf3uy; 0x9auy; 0xd9uy; 0x4cuy; 0x38uy; 0xd1uy; 0xc8uy; 0x24uy; 0x79uy; 0xe2uy; 0xdduy; 0x21uy; 0x59uy; 0xa0uy; 0x77uy; 0x02uy; 0x4buy; 0x05uy; 0x89uy; 0xbcuy; 0x8auy; 0x20uy; 0x10uy; 0x1buy; 0x50uy; 0x6fuy; 0x0auy; 0x1auy; 0xd0uy; 0xbbuy; 0xabuy; 0x76uy; 0xe8uy; 0x3auy; 0x83uy; 0xf1uy; 0xb9uy; 0x4buy; 0xe6uy; 0xbeuy; 0xaeuy; 0x74uy; 0xe8uy; 0x74uy; 0xcauy; 0xb6uy; 0x92uy; 0xc5uy; 0x96uy; 0x3auy; 0x75uy; 0x43uy; 0x6buy; 0x77uy; 0x61uy; 0x21uy; 0xecuy; 0x9fuy; 0x62uy; 0x39uy; 0x9auy; 0x3euy; 0x66uy; 0xb2uy; 0xd2uy; 0x27uy; 0x07uy; 0xdauy; 0xe8uy; 0x19uy; 0x33uy; 0xb6uy; 0x27uy; 0x7fuy; 0x3cuy; 0x85uy; 0x16uy; 0xbcuy; 0xbeuy; 0x26uy; 0xdbuy; 0xbduy; 0x86uy; 0xf3uy; 0x73uy; 0x10uy; 0x3duy; 0x7cuy; 0xf4uy; 0xcauy; 0xd1uy; 0x88uy; 0x8cuy; 0x95uy; 0x21uy; 0x18uy; 0xfbuy; 0xfbuy; 0xd0uy; 0xd7uy; 0xb4uy; 0xbeuy; 0xdcuy; 0x4auy; 0xe4uy; 0x93uy; 0x6auy; 0xffuy; 0x91uy; 0x15uy; 0x7euy; 0x7auy; 0xa4uy; 0x7cuy; 0x54uy; 0x44uy; 0x2euy; 0xa7uy; 0x8duy; 0x6auy; 0xc2uy; 0x51uy; 0xd3uy; 0x24uy; 0xa0uy; 0xfbuy; 0xe4uy; 0x9duy; 0x89uy; 0xccuy; 0x35uy; 0x21uy; 0xb6uy; 0x6duy; 0x16uy; 0xe9uy; 0xc6uy; 0x6auy; 0x37uy; 0x09uy; 0x89uy; 0x4euy; 0x4euy; 0xb0uy; 0xa4uy; 0xeeuy; 0xdcuy; 0x4auy; 0xe1uy; 0x94uy; 0x68uy; 0xe6uy; 0x6buy; 0x81uy; 0xf2uy; 0x71uy; 0x35uy; 0x1buy; 0x1duy; 0x92uy; 0x1euy; 0xa5uy; 0x51uy; 0x04uy; 0x7auy; 0xbcuy; 0xc6uy; 0xb8uy; 0x7auy; 0x90uy; 0x1fuy; 0xdeuy; 0x7duy; 0xb7uy; 0x9fuy; 0xa1uy; 0x81uy; 0x8cuy; 0x11uy; 0x33uy; 0x6duy; 0xbcuy; 0x07uy; 0x24uy; 0x4auy; 0x40uy; 0xebuy; ] in
assert_norm (List.Tot.length l = 208);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input16_len: (x:UInt32.t { UInt32.v x = B.length input16 }) =
208ul
let key16: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; 0x09uy; 0x0auy; 0x0buy; 0x0cuy; 0x0duy; 0x0euy; 0x0fuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key16_len: (x:UInt32.t { UInt32.v x = B.length key16 }) =
32ul
let tag16: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbcuy; 0x93uy; 0x9buy; 0xc5uy; 0x28uy; 0x14uy; 0x80uy; 0xfauy; 0x99uy; 0xc6uy; 0xd6uy; 0x8cuy; 0x25uy; 0x8euy; 0xc4uy; 0x2fuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag16_len: (x:UInt32.t { UInt32.v x = B.length tag16 }) =
16ul
let input17: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input17_len: (x:UInt32.t { UInt32.v x = B.length input17 }) =
0ul
let key17: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0xafuy; 0xaauy; 0xc3uy; 0x31uy; 0xeeuy; 0x37uy; 0x2cuy; 0xd6uy; 0x08uy; 0x2duy; 0xe1uy; 0x34uy; 0x94uy; 0x3buy; 0x17uy; 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key17_len: (x:UInt32.t { UInt32.v x = B.length key17 }) =
32ul
let tag17: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x10uy; 0x13uy; 0x0euy; 0x9fuy; 0x6fuy; 0xeauy; 0x8duy; 0x72uy; 0x29uy; 0x38uy; 0x50uy; 0xa6uy; 0x67uy; 0xd8uy; 0x6cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag17_len: (x:UInt32.t { UInt32.v x = B.length tag17 }) =
16ul
let input18: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x65uy; 0x6cuy; 0x6cuy; 0x6fuy; 0x20uy; 0x77uy; 0x6fuy; 0x72uy; 0x6cuy; 0x64uy; 0x21uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input18_len: (x:UInt32.t { UInt32.v x = B.length input18 }) =
12ul
let key18: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key18_len: (x:UInt32.t { UInt32.v x = B.length key18 }) =
32ul
let tag18: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa6uy; 0xf7uy; 0x45uy; 0x00uy; 0x8fuy; 0x81uy; 0xc9uy; 0x16uy; 0xa2uy; 0x0duy; 0xccuy; 0x74uy; 0xeeuy; 0xf2uy; 0xb2uy; 0xf0uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag18_len: (x:UInt32.t { UInt32.v x = B.length tag18 }) =
16ul
let input19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input19_len: (x:UInt32.t { UInt32.v x = B.length input19 }) =
32ul
let key19: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x74uy; 0x68uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x33uy; 0x32uy; 0x2duy; 0x62uy; 0x79uy; 0x74uy; 0x65uy; 0x20uy; 0x6buy; 0x65uy; 0x79uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x50uy; 0x6fuy; 0x6cuy; 0x79uy; 0x31uy; 0x33uy; 0x30uy; 0x35uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key19_len: (x:UInt32.t { UInt32.v x = B.length key19 }) =
32ul
let tag19: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x49uy; 0xecuy; 0x78uy; 0x09uy; 0x0euy; 0x48uy; 0x1euy; 0xc6uy; 0xc2uy; 0x6buy; 0x33uy; 0xb9uy; 0x1cuy; 0xccuy; 0x03uy; 0x07uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag19_len: (x:UInt32.t { UInt32.v x = B.length tag19 }) =
16ul
let input20: (b: B.buffer UInt8.t { B.length b = 128 /\ B.recallable b }) =
[@inline_let] let l = [ 0x89uy; 0xdauy; 0xb8uy; 0x0buy; 0x77uy; 0x17uy; 0xc1uy; 0xdbuy; 0x5duy; 0xb4uy; 0x37uy; 0x86uy; 0x0auy; 0x3fuy; 0x70uy; 0x21uy; 0x8euy; 0x93uy; 0xe1uy; 0xb8uy; 0xf4uy; 0x61uy; 0xfbuy; 0x67uy; 0x7fuy; 0x16uy; 0xf3uy; 0x5fuy; 0x6fuy; 0x87uy; 0xe2uy; 0xa9uy; 0x1cuy; 0x99uy; 0xbcuy; 0x3auy; 0x47uy; 0xacuy; 0xe4uy; 0x76uy; 0x40uy; 0xccuy; 0x95uy; 0xc3uy; 0x45uy; 0xbeuy; 0x5euy; 0xccuy; 0xa5uy; 0xa3uy; 0x52uy; 0x3cuy; 0x35uy; 0xccuy; 0x01uy; 0x89uy; 0x3auy; 0xf0uy; 0xb6uy; 0x4auy; 0x62uy; 0x03uy; 0x34uy; 0x27uy; 0x03uy; 0x72uy; 0xecuy; 0x12uy; 0x48uy; 0x2duy; 0x1buy; 0x1euy; 0x36uy; 0x35uy; 0x61uy; 0x69uy; 0x8auy; 0x57uy; 0x8buy; 0x35uy; 0x98uy; 0x03uy; 0x49uy; 0x5buy; 0xb4uy; 0xe2uy; 0xefuy; 0x19uy; 0x30uy; 0xb1uy; 0x7auy; 0x51uy; 0x90uy; 0xb5uy; 0x80uy; 0xf1uy; 0x41uy; 0x30uy; 0x0duy; 0xf3uy; 0x0auy; 0xdbuy; 0xecuy; 0xa2uy; 0x8fuy; 0x64uy; 0x27uy; 0xa8uy; 0xbcuy; 0x1auy; 0x99uy; 0x9fuy; 0xd5uy; 0x1cuy; 0x55uy; 0x4auy; 0x01uy; 0x7duy; 0x09uy; 0x5duy; 0x8cuy; 0x3euy; 0x31uy; 0x27uy; 0xdauy; 0xf9uy; 0xf5uy; 0x95uy; ] in
assert_norm (List.Tot.length l = 128);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input20_len: (x:UInt32.t { UInt32.v x = B.length input20 }) =
128ul
let key20: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0x77uy; 0x3buy; 0xe3uy; 0x7auy; 0xdbuy; 0x1euy; 0x4duy; 0x68uy; 0x3buy; 0xf0uy; 0x07uy; 0x5euy; 0x79uy; 0xc4uy; 0xeeuy; 0x03uy; 0x79uy; 0x18uy; 0x53uy; 0x5auy; 0x7fuy; 0x99uy; 0xccuy; 0xb7uy; 0x04uy; 0x0fuy; 0xb5uy; 0xf5uy; 0xf4uy; 0x3auy; 0xeauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key20_len: (x:UInt32.t { UInt32.v x = B.length key20 }) =
32ul
let tag20: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xc8uy; 0x5duy; 0x15uy; 0xeduy; 0x44uy; 0xc3uy; 0x78uy; 0xd6uy; 0xb0uy; 0x0euy; 0x23uy; 0x06uy; 0x4cuy; 0x7buy; 0xcduy; 0x51uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag20_len: (x:UInt32.t { UInt32.v x = B.length tag20 }) =
16ul
let input21: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0buy; 0x17uy; 0x03uy; 0x03uy; 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x06uy; 0xdbuy; 0x1fuy; 0x1fuy; 0x36uy; 0x8duy; 0x69uy; 0x6auy; 0x81uy; 0x0auy; 0x34uy; 0x9cuy; 0x0cuy; 0x71uy; 0x4cuy; 0x9auy; 0x5euy; 0x78uy; 0x50uy; 0xc2uy; 0x40uy; 0x7duy; 0x72uy; 0x1auy; 0xcduy; 0xeduy; 0x95uy; 0xe0uy; 0x18uy; 0xd7uy; 0xa8uy; 0x52uy; 0x66uy; 0xa6uy; 0xe1uy; 0x28uy; 0x9cuy; 0xdbuy; 0x4auy; 0xebuy; 0x18uy; 0xdauy; 0x5auy; 0xc8uy; 0xa2uy; 0xb0uy; 0x02uy; 0x6duy; 0x24uy; 0xa5uy; 0x9auy; 0xd4uy; 0x85uy; 0x22uy; 0x7fuy; 0x3euy; 0xaeuy; 0xdbuy; 0xb2uy; 0xe7uy; 0xe3uy; 0x5euy; 0x1cuy; 0x66uy; 0xcduy; 0x60uy; 0xf9uy; 0xabuy; 0xf7uy; 0x16uy; 0xdcuy; 0xc9uy; 0xacuy; 0x42uy; 0x68uy; 0x2duy; 0xd7uy; 0xdauy; 0xb2uy; 0x87uy; 0xa7uy; 0x02uy; 0x4cuy; 0x4euy; 0xefuy; 0xc3uy; 0x21uy; 0xccuy; 0x05uy; 0x74uy; 0xe1uy; 0x67uy; 0x93uy; 0xe3uy; 0x7cuy; 0xecuy; 0x03uy; 0xc5uy; 0xbduy; 0xa4uy; 0x2buy; 0x54uy; 0xc1uy; 0x14uy; 0xa8uy; 0x0buy; 0x57uy; 0xafuy; 0x26uy; 0x41uy; 0x6cuy; 0x7buy; 0xe7uy; 0x42uy; 0x00uy; 0x5euy; 0x20uy; 0x85uy; 0x5cuy; 0x73uy; 0xe2uy; 0x1duy; 0xc8uy; 0xe2uy; 0xeduy; 0xc9uy; 0xd4uy; 0x35uy; 0xcbuy; 0x6fuy; 0x60uy; 0x59uy; 0x28uy; 0x00uy; 0x11uy; 0xc2uy; 0x70uy; 0xb7uy; 0x15uy; 0x70uy; 0x05uy; 0x1cuy; 0x1cuy; 0x9buy; 0x30uy; 0x52uy; 0x12uy; 0x66uy; 0x20uy; 0xbcuy; 0x1euy; 0x27uy; 0x30uy; 0xfauy; 0x06uy; 0x6cuy; 0x7auy; 0x50uy; 0x9duy; 0x53uy; 0xc6uy; 0x0euy; 0x5auy; 0xe1uy; 0xb4uy; 0x0auy; 0xa6uy; 0xe3uy; 0x9euy; 0x49uy; 0x66uy; 0x92uy; 0x28uy; 0xc9uy; 0x0euy; 0xecuy; 0xb4uy; 0xa5uy; 0x0duy; 0xb3uy; 0x2auy; 0x50uy; 0xbcuy; 0x49uy; 0xe9uy; 0x0buy; 0x4fuy; 0x4buy; 0x35uy; 0x9auy; 0x1duy; 0xfduy; 0x11uy; 0x74uy; 0x9cuy; 0xd3uy; 0x86uy; 0x7fuy; 0xcfuy; 0x2fuy; 0xb7uy; 0xbbuy; 0x6cuy; 0xd4uy; 0x73uy; 0x8fuy; 0x6auy; 0x4auy; 0xd6uy; 0xf7uy; 0xcauy; 0x50uy; 0x58uy; 0xf7uy; 0x61uy; 0x88uy; 0x45uy; 0xafuy; 0x9fuy; 0x02uy; 0x0fuy; 0x6cuy; 0x3buy; 0x96uy; 0x7buy; 0x8fuy; 0x4cuy; 0xd4uy; 0xa9uy; 0x1euy; 0x28uy; 0x13uy; 0xb5uy; 0x07uy; 0xaeuy; 0x66uy; 0xf2uy; 0xd3uy; 0x5cuy; 0x18uy; 0x28uy; 0x4fuy; 0x72uy; 0x92uy; 0x18uy; 0x60uy; 0x62uy; 0xe1uy; 0x0fuy; 0xd5uy; 0x51uy; 0x0duy; 0x18uy; 0x77uy; 0x53uy; 0x51uy; 0xefuy; 0x33uy; 0x4euy; 0x76uy; 0x34uy; 0xabuy; 0x47uy; 0x43uy; 0xf5uy; 0xb6uy; 0x8fuy; 0x49uy; 0xaduy; 0xcauy; 0xb3uy; 0x84uy; 0xd3uy; 0xfduy; 0x75uy; 0xf7uy; 0x39uy; 0x0fuy; 0x40uy; 0x06uy; 0xefuy; 0x2auy; 0x29uy; 0x5cuy; 0x8cuy; 0x7auy; 0x07uy; 0x6auy; 0xd5uy; 0x45uy; 0x46uy; 0xcduy; 0x25uy; 0xd2uy; 0x10uy; 0x7fuy; 0xbeuy; 0x14uy; 0x36uy; 0xc8uy; 0x40uy; 0x92uy; 0x4auy; 0xaeuy; 0xbeuy; 0x5buy; 0x37uy; 0x08uy; 0x93uy; 0xcduy; 0x63uy; 0xd1uy; 0x32uy; 0x5buy; 0x86uy; 0x16uy; 0xfcuy; 0x48uy; 0x10uy; 0x88uy; 0x6buy; 0xc1uy; 0x52uy; 0xc5uy; 0x32uy; 0x21uy; 0xb6uy; 0xdfuy; 0x37uy; 0x31uy; 0x19uy; 0x39uy; 0x32uy; 0x55uy; 0xeeuy; 0x72uy; 0xbcuy; 0xaauy; 0x88uy; 0x01uy; 0x74uy; 0xf1uy; 0x71uy; 0x7fuy; 0x91uy; 0x84uy; 0xfauy; 0x91uy; 0x64uy; 0x6fuy; 0x17uy; 0xa2uy; 0x4auy; 0xc5uy; 0x5duy; 0x16uy; 0xbfuy; 0xdduy; 0xcauy; 0x95uy; 0x81uy; 0xa9uy; 0x2euy; 0xdauy; 0x47uy; 0x92uy; 0x01uy; 0xf0uy; 0xeduy; 0xbfuy; 0x63uy; 0x36uy; 0x00uy; 0xd6uy; 0x06uy; 0x6duy; 0x1auy; 0xb3uy; 0x6duy; 0x5duy; 0x24uy; 0x15uy; 0xd7uy; 0x13uy; 0x51uy; 0xbbuy; 0xcduy; 0x60uy; 0x8auy; 0x25uy; 0x10uy; 0x8duy; 0x25uy; 0x64uy; 0x19uy; 0x92uy; 0xc1uy; 0xf2uy; 0x6cuy; 0x53uy; 0x1cuy; 0xf9uy; 0xf9uy; 0x02uy; 0x03uy; 0xbcuy; 0x4cuy; 0xc1uy; 0x9fuy; 0x59uy; 0x27uy; 0xd8uy; 0x34uy; 0xb0uy; 0xa4uy; 0x71uy; 0x16uy; 0xd3uy; 0x88uy; 0x4buy; 0xbbuy; 0x16uy; 0x4buy; 0x8euy; 0xc8uy; 0x83uy; 0xd1uy; 0xacuy; 0x83uy; 0x2euy; 0x56uy; 0xb3uy; 0x91uy; 0x8auy; 0x98uy; 0x60uy; 0x1auy; 0x08uy; 0xd1uy; 0x71uy; 0x88uy; 0x15uy; 0x41uy; 0xd5uy; 0x94uy; 0xdbuy; 0x39uy; 0x9cuy; 0x6auy; 0xe6uy; 0x15uy; 0x12uy; 0x21uy; 0x74uy; 0x5auy; 0xecuy; 0x81uy; 0x4cuy; 0x45uy; 0xb0uy; 0xb0uy; 0x5buy; 0x56uy; 0x54uy; 0x36uy; 0xfduy; 0x6fuy; 0x13uy; 0x7auy; 0xa1uy; 0x0auy; 0x0cuy; 0x0buy; 0x64uy; 0x37uy; 0x61uy; 0xdbuy; 0xd6uy; 0xf9uy; 0xa9uy; 0xdcuy; 0xb9uy; 0x9buy; 0x1auy; 0x6euy; 0x69uy; 0x08uy; 0x54uy; 0xceuy; 0x07uy; 0x69uy; 0xcduy; 0xe3uy; 0x97uy; 0x61uy; 0xd8uy; 0x2fuy; 0xcduy; 0xecuy; 0x15uy; 0xf0uy; 0xd9uy; 0x2duy; 0x7duy; 0x8euy; 0x94uy; 0xaduy; 0xe8uy; 0xebuy; 0x83uy; 0xfbuy; 0xe0uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input21_len: (x:UInt32.t { UInt32.v x = B.length input21 }) =
528ul
let key21: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x99uy; 0xe5uy; 0x82uy; 0x2duy; 0xd4uy; 0x17uy; 0x3cuy; 0x99uy; 0x5euy; 0x3duy; 0xaeuy; 0x0duy; 0xdeuy; 0xfbuy; 0x97uy; 0x74uy; 0x3fuy; 0xdeuy; 0x3buy; 0x08uy; 0x01uy; 0x34uy; 0xb3uy; 0x9fuy; 0x76uy; 0xe9uy; 0xbfuy; 0x8duy; 0x0euy; 0x88uy; 0xd5uy; 0x46uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key21_len: (x:UInt32.t { UInt32.v x = B.length key21 }) =
32ul
let tag21: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x26uy; 0x37uy; 0x40uy; 0x8fuy; 0xe1uy; 0x30uy; 0x86uy; 0xeauy; 0x73uy; 0xf9uy; 0x71uy; 0xe3uy; 0x42uy; 0x5euy; 0x28uy; 0x20uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag21_len: (x:UInt32.t { UInt32.v x = B.length tag21 }) =
16ul
let input22: (b: B.buffer UInt8.t { B.length b = 257 /\ B.recallable b }) =
[@inline_let] let l = [ 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x80uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xceuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xc5uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe3uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xacuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xe6uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0x00uy; 0x00uy; 0x00uy; 0xafuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xffuy; 0xffuy; 0xffuy; 0xf5uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xe7uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x71uy; 0x92uy; 0x05uy; 0xa8uy; 0x52uy; 0x1duy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 257);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input22_len: (x:UInt32.t { UInt32.v x = B.length input22 }) =
257ul
let key22: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7fuy; 0x1buy; 0x02uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; 0xccuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key22_len: (x:UInt32.t { UInt32.v x = B.length key22 }) =
32ul
let tag22: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x59uy; 0xb8uy; 0x76uy; 0xecuy; 0xeeuy; 0xd6uy; 0x6euy; 0xb3uy; 0x77uy; 0x98uy; 0xc0uy; 0x45uy; 0x7buy; 0xafuy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag22_len: (x:UInt32.t { UInt32.v x = B.length tag22 }) =
16ul
let input23: (b: B.buffer UInt8.t { B.length b = 39 /\ B.recallable b }) =
[@inline_let] let l = [ 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x80uy; 0x02uy; 0x64uy; ] in
assert_norm (List.Tot.length l = 39);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input23_len: (x:UInt32.t { UInt32.v x = B.length input23 }) =
39ul
let key23: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe0uy; 0x00uy; 0x16uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; 0xaauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key23_len: (x:UInt32.t { UInt32.v x = B.length key23 }) =
32ul
let tag23: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xbduy; 0x12uy; 0x58uy; 0x97uy; 0x8euy; 0x20uy; 0x54uy; 0x44uy; 0xc9uy; 0xaauy; 0xaauy; 0x82uy; 0x00uy; 0x6fuy; 0xeduy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag23_len: (x:UInt32.t { UInt32.v x = B.length tag23 }) =
16ul
let input24: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input24_len: (x:UInt32.t { UInt32.v x = B.length input24 }) =
2ul
let key24: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key24_len: (x:UInt32.t { UInt32.v x = B.length key24 }) =
32ul
let tag24: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x06uy; 0x12uy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; 0x0cuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag24_len: (x:UInt32.t { UInt32.v x = B.length tag24 }) =
16ul
let input25: (b: B.buffer UInt8.t { B.length b = 415 /\ B.recallable b }) =
[@inline_let] let l = [ 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7auy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x5cuy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x7buy; 0x6euy; 0x7buy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x13uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xb3uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xf2uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0xefuy; 0xffuy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7auy; 0x00uy; 0x00uy; 0x10uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x09uy; 0x00uy; 0x00uy; 0x00uy; 0x64uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfcuy; ] in
assert_norm (List.Tot.length l = 415);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input25_len: (x:UInt32.t { UInt32.v x = B.length input25 }) =
415ul
let key25: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0xffuy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x1euy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x7buy; 0x7buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key25_len: (x:UInt32.t { UInt32.v x = B.length key25 }) =
32ul
let tag25: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x20uy; 0x5buy; 0xbfuy; 0x9euy; 0x9fuy; 0x8fuy; 0x72uy; 0x12uy; 0xabuy; 0x9euy; 0x2auy; 0xb9uy; 0xb7uy; 0xe4uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag25_len: (x:UInt32.t { UInt32.v x = B.length tag25 }) =
16ul
let input26: (b: B.buffer UInt8.t { B.length b = 118 /\ B.recallable b }) =
[@inline_let] let l = [ 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0xffuy; 0xffuy; 0xffuy; 0xe9uy; 0xe9uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x00uy; 0x00uy; 0xacuy; 0xacuy; 0xecuy; 0x01uy; 0x00uy; 0xacuy; 0xacuy; 0xacuy; 0x2cuy; 0xacuy; 0xa2uy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0xacuy; 0x64uy; 0xf2uy; ] in
assert_norm (List.Tot.length l = 118);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input26_len: (x:UInt32.t { UInt32.v x = B.length input26 }) =
118ul
let key26: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x00uy; 0x00uy; 0x00uy; 0x7fuy; 0x01uy; 0x00uy; 0x00uy; 0x20uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcfuy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key26_len: (x:UInt32.t { UInt32.v x = B.length key26 }) =
32ul
let tag26: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0xeeuy; 0x7cuy; 0x8cuy; 0x54uy; 0x6duy; 0xdeuy; 0xb1uy; 0xa4uy; 0x67uy; 0xe4uy; 0xc3uy; 0x98uy; 0x11uy; 0x58uy; 0xb9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag26_len: (x:UInt32.t { UInt32.v x = B.length tag26 }) =
16ul
let input27: (b: B.buffer UInt8.t { B.length b = 131 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8euy; 0x99uy; 0x3buy; 0x9fuy; 0x48uy; 0x68uy; 0x12uy; 0x73uy; 0xc2uy; 0x96uy; 0x50uy; 0xbauy; 0x32uy; 0xfcuy; 0x76uy; 0xceuy; 0x48uy; 0x33uy; 0x2euy; 0xa7uy; 0x16uy; 0x4duy; 0x96uy; 0xa4uy; 0x47uy; 0x6fuy; 0xb8uy; 0xc5uy; 0x31uy; 0xa1uy; 0x18uy; 0x6auy; 0xc0uy; 0xdfuy; 0xc1uy; 0x7cuy; 0x98uy; 0xdcuy; 0xe8uy; 0x7buy; 0x4duy; 0xa7uy; 0xf0uy; 0x11uy; 0xecuy; 0x48uy; 0xc9uy; 0x72uy; 0x71uy; 0xd2uy; 0xc2uy; 0x0fuy; 0x9buy; 0x92uy; 0x8fuy; 0xe2uy; 0x27uy; 0x0duy; 0x6fuy; 0xb8uy; 0x63uy; 0xd5uy; 0x17uy; 0x38uy; 0xb4uy; 0x8euy; 0xeeuy; 0xe3uy; 0x14uy; 0xa7uy; 0xccuy; 0x8auy; 0xb9uy; 0x32uy; 0x16uy; 0x45uy; 0x48uy; 0xe5uy; 0x26uy; 0xaeuy; 0x90uy; 0x22uy; 0x43uy; 0x68uy; 0x51uy; 0x7auy; 0xcfuy; 0xeauy; 0xbduy; 0x6buy; 0xb3uy; 0x73uy; 0x2buy; 0xc0uy; 0xe9uy; 0xdauy; 0x99uy; 0x83uy; 0x2buy; 0x61uy; 0xcauy; 0x01uy; 0xb6uy; 0xdeuy; 0x56uy; 0x24uy; 0x4auy; 0x9euy; 0x88uy; 0xd5uy; 0xf9uy; 0xb3uy; 0x79uy; 0x73uy; 0xf6uy; 0x22uy; 0xa4uy; 0x3duy; 0x14uy; 0xa6uy; 0x59uy; 0x9buy; 0x1fuy; 0x65uy; 0x4cuy; 0xb4uy; 0x5auy; 0x74uy; 0xe3uy; 0x55uy; 0xa5uy; ] in
assert_norm (List.Tot.length l = 131);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input27_len: (x:UInt32.t { UInt32.v x = B.length input27 }) =
131ul
let key27: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeeuy; 0xa6uy; 0xa7uy; 0x25uy; 0x1cuy; 0x1euy; 0x72uy; 0x91uy; 0x6duy; 0x11uy; 0xc2uy; 0xcbuy; 0x21uy; 0x4duy; 0x3cuy; 0x25uy; 0x25uy; 0x39uy; 0x12uy; 0x1duy; 0x8euy; 0x23uy; 0x4euy; 0x65uy; 0x2duy; 0x65uy; 0x1fuy; 0xa4uy; 0xc8uy; 0xcfuy; 0xf8uy; 0x80uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key27_len: (x:UInt32.t { UInt32.v x = B.length key27 }) =
32ul
let tag27: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xffuy; 0xc7uy; 0x70uy; 0x3fuy; 0x94uy; 0x00uy; 0xe5uy; 0x2auy; 0x7duy; 0xfbuy; 0x4buy; 0x3duy; 0x33uy; 0x05uy; 0xd9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag27_len: (x:UInt32.t { UInt32.v x = B.length tag27 }) =
16ul
let input28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input28_len: (x:UInt32.t { UInt32.v x = B.length input28 }) =
16ul
let key28: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key28_len: (x:UInt32.t { UInt32.v x = B.length key28 }) =
32ul
let tag28: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag28_len: (x:UInt32.t { UInt32.v x = B.length tag28 }) =
16ul
let input29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input29_len: (x:UInt32.t { UInt32.v x = B.length input29 }) =
16ul
let key29: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key29_len: (x:UInt32.t { UInt32.v x = B.length key29 }) =
32ul
let tag29: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x03uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag29_len: (x:UInt32.t { UInt32.v x = B.length tag29 }) =
16ul
let input30: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xf0uy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x11uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input30_len: (x:UInt32.t { UInt32.v x = B.length input30 }) =
48ul
let key30: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key30_len: (x:UInt32.t { UInt32.v x = B.length key30 }) =
32ul
let tag30: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x05uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag30_len: (x:UInt32.t { UInt32.v x = B.length tag30 }) =
16ul
let input31: (b: B.buffer UInt8.t { B.length b = 48 /\ B.recallable b }) =
[@inline_let] let l = [ 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xfbuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0xfeuy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 48);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input31_len: (x:UInt32.t { UInt32.v x = B.length input31 }) =
48ul
let key31: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x01uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key31_len: (x:UInt32.t { UInt32.v x = B.length key31 }) =
32ul
let tag31: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag31_len: (x:UInt32.t { UInt32.v x = B.length tag31 }) =
16ul
let input32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input32_len: (x:UInt32.t { UInt32.v x = B.length input32 }) =
16ul
let key32: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x02uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key32_len: (x:UInt32.t { UInt32.v x = B.length key32 }) =
32ul
let tag32: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfauy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; 0xffuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag32_len: (x:UInt32.t { UInt32.v x = B.length tag32 }) =
16ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input33:(b: B.buffer UInt8.t {B.length b = 64 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input33 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 64 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 802,
"start_col": 2,
"start_line": 800
} |
Prims.Tot | val input0_len:(x: UInt32.t{UInt32.v x = B.length input0}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul | val input0_len:(x: UInt32.t{UInt32.v x = B.length input0})
let input0_len:(x: UInt32.t{UInt32.v x = B.length input0}) = | false | null | false | 34ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input0_len:(x: UInt32.t{UInt32.v x = B.length input0}) | [] | Test.Vectors.Poly1305.input0_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input0} | {
"end_col": 6,
"end_line": 13,
"start_col": 2,
"start_line": 13
} |
Prims.Tot | val key0_len:(x: UInt32.t{UInt32.v x = B.length key0}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul | val key0_len:(x: UInt32.t{UInt32.v x = B.length key0})
let key0_len:(x: UInt32.t{UInt32.v x = B.length key0}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key0_len:(x: UInt32.t{UInt32.v x = B.length key0}) | [] | Test.Vectors.Poly1305.key0_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key0} | {
"end_col": 6,
"end_line": 21,
"start_col": 2,
"start_line": 21
} |
Prims.Tot | val input1_len:(x: UInt32.t{UInt32.v x = B.length input1}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul | val input1_len:(x: UInt32.t{UInt32.v x = B.length input1})
let input1_len:(x: UInt32.t{UInt32.v x = B.length input1}) = | false | null | false | 2ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input1_len:(x: UInt32.t{UInt32.v x = B.length input1}) | [] | Test.Vectors.Poly1305.input1_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input1} | {
"end_col": 5,
"end_line": 37,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | val tag0:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag0:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag0:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy;
0x0cuy; 0x01uy; 0x27uy; 0xa9uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag0:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag0 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 26,
"start_col": 2,
"start_line": 24
} |
Prims.Tot | val key1_len:(x: UInt32.t{UInt32.v x = B.length key1}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul | val key1_len:(x: UInt32.t{UInt32.v x = B.length key1})
let key1_len:(x: UInt32.t{UInt32.v x = B.length key1}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key1_len:(x: UInt32.t{UInt32.v x = B.length key1}) | [] | Test.Vectors.Poly1305.key1_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key1} | {
"end_col": 6,
"end_line": 45,
"start_col": 2,
"start_line": 45
} |
Prims.Tot | val tag0_len:(x: UInt32.t{UInt32.v x = B.length tag0}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul | val tag0_len:(x: UInt32.t{UInt32.v x = B.length tag0})
let tag0_len:(x: UInt32.t{UInt32.v x = B.length tag0}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag0_len:(x: UInt32.t{UInt32.v x = B.length tag0}) | [] | Test.Vectors.Poly1305.tag0_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag0} | {
"end_col": 6,
"end_line": 29,
"start_col": 2,
"start_line": 29
} |
Prims.Tot | val key0:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key0:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key0:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy;
0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy;
0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key0:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key0 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 18,
"start_col": 2,
"start_line": 16
} |
Prims.Tot | val tag1:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag1:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag1:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy;
0xb8uy; 0x19uy; 0x53uy; 0xdeuy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag1:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag1 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 50,
"start_col": 2,
"start_line": 48
} |
Prims.Tot | val key1:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key1:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key1:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy;
0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy;
0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key1:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key1 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 42,
"start_col": 2,
"start_line": 40
} |
Prims.Tot | val input2:(b: B.buffer UInt8.t {B.length b = 0 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l | val input2:(b: B.buffer UInt8.t {B.length b = 0 /\ B.recallable b})
let input2:(b: B.buffer UInt8.t {B.length b = 0 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l = [] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input2:(b: B.buffer UInt8.t {B.length b = 0 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input2 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 0 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 58,
"start_col": 2,
"start_line": 56
} |
Prims.Tot | val key2_len:(x: UInt32.t{UInt32.v x = B.length key2}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul | val key2_len:(x: UInt32.t{UInt32.v x = B.length key2})
let key2_len:(x: UInt32.t{UInt32.v x = B.length key2}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key2_len:(x: UInt32.t{UInt32.v x = B.length key2}) | [] | Test.Vectors.Poly1305.key2_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key2} | {
"end_col": 6,
"end_line": 69,
"start_col": 2,
"start_line": 69
} |
Prims.Tot | val key3_len:(x: UInt32.t{UInt32.v x = B.length key3}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul | val key3_len:(x: UInt32.t{UInt32.v x = B.length key3})
let key3_len:(x: UInt32.t{UInt32.v x = B.length key3}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key3_len:(x: UInt32.t{UInt32.v x = B.length key3}) | [] | Test.Vectors.Poly1305.key3_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.key3} | {
"end_col": 6,
"end_line": 93,
"start_col": 2,
"start_line": 93
} |
Prims.Tot | val input3_len:(x: UInt32.t{UInt32.v x = B.length input3}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul | val input3_len:(x: UInt32.t{UInt32.v x = B.length input3})
let input3_len:(x: UInt32.t{UInt32.v x = B.length input3}) = | false | null | false | 32ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input3_len:(x: UInt32.t{UInt32.v x = B.length input3}) | [] | Test.Vectors.Poly1305.input3_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input3} | {
"end_col": 6,
"end_line": 85,
"start_col": 2,
"start_line": 85
} |
Prims.Tot | val tag2:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag2:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag2:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy;
0x29uy; 0xccuy; 0x2euy; 0xe7uy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag2:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag2 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 74,
"start_col": 2,
"start_line": 72
} |
Prims.Tot | val key2:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key2:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key2:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy;
0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy;
0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key2:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key2 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 66,
"start_col": 2,
"start_line": 64
} |
Prims.Tot | val tag3_len:(x: UInt32.t{UInt32.v x = B.length tag3}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul | val tag3_len:(x: UInt32.t{UInt32.v x = B.length tag3})
let tag3_len:(x: UInt32.t{UInt32.v x = B.length tag3}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag3_len:(x: UInt32.t{UInt32.v x = B.length tag3}) | [] | Test.Vectors.Poly1305.tag3_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag3} | {
"end_col": 6,
"end_line": 101,
"start_col": 2,
"start_line": 101
} |
Prims.Tot | val tag3:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag3:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag3:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy;
0x3cuy; 0x01uy; 0xcduy; 0xbeuy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag3:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag3 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 98,
"start_col": 2,
"start_line": 96
} |
Prims.Tot | val input4_len:(x: UInt32.t{UInt32.v x = B.length input4}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul | val input4_len:(x: UInt32.t{UInt32.v x = B.length input4})
let input4_len:(x: UInt32.t{UInt32.v x = B.length input4}) = | false | null | false | 63ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input4_len:(x: UInt32.t{UInt32.v x = B.length input4}) | [] | Test.Vectors.Poly1305.input4_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.input4} | {
"end_col": 6,
"end_line": 109,
"start_col": 2,
"start_line": 109
} |
Prims.Tot | val tag4_len:(x: UInt32.t{UInt32.v x = B.length tag4}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag4_len: (x:UInt32.t { UInt32.v x = B.length tag4 }) =
16ul | val tag4_len:(x: UInt32.t{UInt32.v x = B.length tag4})
let tag4_len:(x: UInt32.t{UInt32.v x = B.length tag4}) = | false | null | false | 16ul | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag4_len:(x: UInt32.t{UInt32.v x = B.length tag4}) | [] | Test.Vectors.Poly1305.tag4_len | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: FStar.UInt32.t{FStar.UInt32.v x = LowStar.Monotonic.Buffer.length Test.Vectors.Poly1305.tag4} | {
"end_col": 6,
"end_line": 125,
"start_col": 2,
"start_line": 125
} |
Prims.Tot | val key3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val key3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let key3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy;
0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy;
0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.key3 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 90,
"start_col": 2,
"start_line": 88
} |
Prims.Tot | val tag4:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tag4: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy; 0x48uy; 0x49uy; 0x1fuy; 0x1buy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | val tag4:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b})
let tag4:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x51uy; 0x54uy; 0xaduy; 0x0duy; 0x2cuy; 0xb2uy; 0x6euy; 0x01uy; 0x27uy; 0x4fuy; 0xc5uy; 0x11uy;
0x48uy; 0x49uy; 0x1fuy; 0x1buy
]
in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul
let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
32ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x48uy; 0x44uy; 0x3duy; 0x0buy; 0xb0uy; 0xd2uy; 0x11uy; 0x09uy; 0xc8uy; 0x9auy; 0x10uy; 0x0buy; 0x5cuy; 0xe2uy; 0xc2uy; 0x08uy; 0x83uy; 0x14uy; 0x9cuy; 0x69uy; 0xb5uy; 0x61uy; 0xdduy; 0x88uy; 0x29uy; 0x8auy; 0x17uy; 0x98uy; 0xb1uy; 0x07uy; 0x16uy; 0xefuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let tag3: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0x0euy; 0xe1uy; 0xc1uy; 0x6buy; 0xb7uy; 0x3fuy; 0x0fuy; 0x4fuy; 0xd1uy; 0x98uy; 0x81uy; 0x75uy; 0x3cuy; 0x01uy; 0xcduy; 0xbeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag3_len: (x:UInt32.t { UInt32.v x = B.length tag3 }) =
16ul
let input4: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xabuy; 0x08uy; 0x12uy; 0x72uy; 0x4auy; 0x7fuy; 0x1euy; 0x34uy; 0x27uy; 0x42uy; 0xcbuy; 0xeduy; 0x37uy; 0x4duy; 0x94uy; 0xd1uy; 0x36uy; 0xc6uy; 0xb8uy; 0x79uy; 0x5duy; 0x45uy; 0xb3uy; 0x81uy; 0x98uy; 0x30uy; 0xf2uy; 0xc0uy; 0x44uy; 0x91uy; 0xfauy; 0xf0uy; 0x99uy; 0x0cuy; 0x62uy; 0xe4uy; 0x8buy; 0x80uy; 0x18uy; 0xb2uy; 0xc3uy; 0xe4uy; 0xa0uy; 0xfauy; 0x31uy; 0x34uy; 0xcbuy; 0x67uy; 0xfauy; 0x83uy; 0xe1uy; 0x58uy; 0xc9uy; 0x94uy; 0xd9uy; 0x61uy; 0xc4uy; 0xcbuy; 0x21uy; 0x09uy; 0x5cuy; 0x1buy; 0xf9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
63ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x12uy; 0x97uy; 0x6auy; 0x08uy; 0xc4uy; 0x42uy; 0x6duy; 0x0cuy; 0xe8uy; 0xa8uy; 0x24uy; 0x07uy; 0xc4uy; 0xf4uy; 0x82uy; 0x07uy; 0x80uy; 0xf8uy; 0xc2uy; 0x0auy; 0xa7uy; 0x12uy; 0x02uy; 0xd1uy; 0xe2uy; 0x91uy; 0x79uy; 0xcbuy; 0xcbuy; 0x55uy; 0x5auy; 0x57uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tag4:(b: B.buffer UInt8.t {B.length b = 16 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.tag4 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 16 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 122,
"start_col": 2,
"start_line": 120
} |
Prims.Tot | val input3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let input3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy; 0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy; 0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | val input3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b})
let input3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) = | false | null | false | [@@ inline_let ]let l =
[
0x66uy; 0x3cuy; 0xeauy; 0x19uy; 0x0fuy; 0xfbuy; 0x83uy; 0xd8uy; 0x95uy; 0x93uy; 0xf3uy; 0xf4uy;
0x76uy; 0xb6uy; 0xbcuy; 0x24uy; 0xd7uy; 0xe6uy; 0x79uy; 0x10uy; 0x7euy; 0xa2uy; 0x6auy; 0xdbuy;
0x8cuy; 0xafuy; 0x66uy; 0x52uy; 0xd0uy; 0x65uy; 0x61uy; 0x36uy
]
in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l | {
"checked_file": "Test.Vectors.Poly1305.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Poly1305.fst"
} | [
"total"
] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | module Test.Vectors.Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let input0: (b: B.buffer UInt8.t { B.length b = 34 /\ B.recallable b }) =
[@inline_let] let l = [ 0x43uy; 0x72uy; 0x79uy; 0x70uy; 0x74uy; 0x6fuy; 0x67uy; 0x72uy; 0x61uy; 0x70uy; 0x68uy; 0x69uy; 0x63uy; 0x20uy; 0x46uy; 0x6fuy; 0x72uy; 0x75uy; 0x6duy; 0x20uy; 0x52uy; 0x65uy; 0x73uy; 0x65uy; 0x61uy; 0x72uy; 0x63uy; 0x68uy; 0x20uy; 0x47uy; 0x72uy; 0x6fuy; 0x75uy; 0x70uy; ] in
assert_norm (List.Tot.length l = 34);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
34ul
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0xd6uy; 0xbeuy; 0x78uy; 0x57uy; 0x55uy; 0x6duy; 0x33uy; 0x7fuy; 0x44uy; 0x52uy; 0xfeuy; 0x42uy; 0xd5uy; 0x06uy; 0xa8uy; 0x01uy; 0x03uy; 0x80uy; 0x8auy; 0xfbuy; 0x0duy; 0xb2uy; 0xfduy; 0x4auy; 0xbfuy; 0xf6uy; 0xafuy; 0x41uy; 0x49uy; 0xf5uy; 0x1buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let tag0: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa8uy; 0x06uy; 0x1duy; 0xc1uy; 0x30uy; 0x51uy; 0x36uy; 0xc6uy; 0xc2uy; 0x2buy; 0x8buy; 0xafuy; 0x0cuy; 0x01uy; 0x27uy; 0xa9uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag0_len: (x:UInt32.t { UInt32.v x = B.length tag0 }) =
16ul
let input1: (b: B.buffer UInt8.t { B.length b = 2 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0xf6uy; ] in
assert_norm (List.Tot.length l = 2);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
2ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x1fuy; 0xc4uy; 0x0cuy; 0x34uy; 0x67uy; 0xacuy; 0x0buy; 0xe0uy; 0x5cuy; 0xc2uy; 0x04uy; 0x04uy; 0xf3uy; 0xf7uy; 0x00uy; 0x58uy; 0x0buy; 0x3buy; 0x0fuy; 0x94uy; 0x47uy; 0xbbuy; 0x1euy; 0x69uy; 0xd0uy; 0x95uy; 0xb5uy; 0x92uy; 0x8buy; 0x6duy; 0xbcuy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let tag1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf4uy; 0xc6uy; 0x33uy; 0xc3uy; 0x04uy; 0x4fuy; 0xc1uy; 0x45uy; 0xf8uy; 0x4fuy; 0x33uy; 0x5cuy; 0xb8uy; 0x19uy; 0x53uy; 0xdeuy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag1_len: (x:UInt32.t { UInt32.v x = B.length tag1 }) =
16ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xa0uy; 0xf3uy; 0x08uy; 0x00uy; 0x00uy; 0xf4uy; 0x64uy; 0x00uy; 0xd0uy; 0xc7uy; 0xe9uy; 0x07uy; 0x6cuy; 0x83uy; 0x44uy; 0x03uy; 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let tag2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x3fuy; 0xabuy; 0x22uy; 0x51uy; 0xf1uy; 0x1auy; 0xc7uy; 0x59uy; 0xf0uy; 0x88uy; 0x71uy; 0x29uy; 0xccuy; 0x2euy; 0xe7uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let tag2_len: (x:UInt32.t { UInt32.v x = B.length tag2 }) =
16ul | false | false | Test.Vectors.Poly1305.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val input3:(b: B.buffer UInt8.t {B.length b = 32 /\ B.recallable b}) | [] | Test.Vectors.Poly1305.input3 | {
"file_name": "providers/test/vectors/Test.Vectors.Poly1305.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 32 /\ LowStar.Monotonic.Buffer.recallable b} | {
"end_col": 38,
"end_line": 82,
"start_col": 2,
"start_line": 80
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.