Datasets:

microsoft
/

FStarDataSet-V2

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 30.9k rows

file_name stringlengths 5 52	name stringlengths 4 95	original_source_type stringlengths 0 23k	source_type stringlengths 9 23k	source_definition stringlengths 9 57.9k	source dict	source_range dict	file_context stringlengths 0 721k	dependencies dict	opens_and_abbrevs listlengths 2 94	vconfig dict	interleaved bool 1 class	verbose_type stringlengths 1 7.42k	effect stringclasses 118 values	effect_flags sequencelengths 0 2	mutual_with sequencelengths 0 11	ideal_premises sequencelengths 0 236	proof_features sequencelengths 0 1	is_simple_lemma bool 2 classes	is_div bool 2 classes	is_proof bool 2 classes	is_simply_typed bool 2 classes	is_type bool 2 classes	partial_definition stringlengths 5 3.99k	completed_definiton stringlengths 1 1.63M	isa_cross_project_example bool 1 class
Vale.Stdcalls.X64.GCMdecryptOpt.fst	Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_lemma		val gcm128_lemma : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_pre s iv) (Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_post s iv)	let gcm128_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm128_pre s iv) (gcm128_post s iv)) (gcm128_lemma' s iv)	{ "file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCMdecryptOpt.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 173, "end_line": 200, "start_col": 0, "start_line": 200 }	module Vale.Stdcalls.X64.GCMdecryptOpt open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open FStar.Mul module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s module GC = Vale.AES.X64.GCMdecryptOpt open Vale.AES.AES_s open Vale.AES.GCM_s let uint64 = UInt64.t (* A little utility to trigger normalization in types ) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let b128 = buf_t TUInt8 TUInt128 [@__reduce__] noextract let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq [@__reduce__] noextract let t128_mod_pub = TD_Buffer TUInt8 TUInt128 ({modified=true; strict_disjointness=false; taint=MS.Public}) [@__reduce__] noextract let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) [@__reduce__] noextract let tuint64 = TD_Base TUInt64 [@__reduce__] noextract let (dom: list td{List.length dom <= 20}) = let y = [t128_no_mod; tuint64; tuint64; t128_no_mod; t128_mod_pub; t128_no_mod; t128_no_mod; t128_no_mod; t128_mod; tuint64; t128_no_mod; t128_mod; tuint64; t128_mod; tuint64; t128_mod; t128_no_mod] in assert_norm (List.length y = 17); y ( Need to rearrange the order of arguments ) [@__reduce__] noextract let gcm128_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm128_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100" [@__reduce__] noextract let gcm128_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f ( Prove that gcm128_lemma' has the required type *)	{ "checked_file": "/", "dependencies": [ "Vale.X64.State.fsti.checked", "Vale.X64.MemoryAdapters.fsti.checked", "Vale.X64.Memory.fsti.checked", "Vale.X64.Machine_s.fst.checked", "Vale.X64.Decls.fsti.checked", "Vale.Interop.X64.fsti.checked", "Vale.Interop.Base.fst.checked", "Vale.Interop.Assumptions.fst.checked", "Vale.Def.Types_s.fst.checked", "Vale.AsLowStar.Wrapper.fsti.checked", "Vale.AsLowStar.ValeSig.fst.checked", "Vale.AsLowStar.MemoryHelpers.fsti.checked", "Vale.AsLowStar.LowStarSig.fst.checked", "Vale.AES.X64.GCMdecryptOpt.fsti.checked", "Vale.AES.GCM_s.fst.checked", "Vale.AES.AES_s.fst.checked", "prims.fst.checked", "LowStar.BufferView.Up.fsti.checked", "LowStar.BufferView.Down.fsti.checked", "LowStar.Buffer.fst.checked", "FStar.UInt64.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.List.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": false, "source_file": "Vale.Stdcalls.X64.GCMdecryptOpt.fst" }	[ { "abbrev": false, "full_module": "Vale.AES.GCM_s", "short_module": null }, { "abbrev": false, "full_module": "Vale.AES.AES_s", "short_module": null }, { "abbrev": true, "full_module": "Vale.AES.X64.GCMdecryptOpt", "short_module": "GC" }, { "abbrev": true, "full_module": "Vale.X64.Machine_s", "short_module": "MS" }, { "abbrev": true, "full_module": "Vale.X64.State", "short_module": "VS" }, { "abbrev": false, "full_module": "Vale.X64.MemoryAdapters", "short_module": null }, { "abbrev": true, "full_module": "Vale.AsLowStar.Wrapper", "short_module": "W" }, { "abbrev": true, "full_module": "Vale.Interop.Assumptions", "short_module": "IA" }, { "abbrev": true, "full_module": "Vale.X64.Decls", "short_module": "V" }, { "abbrev": true, "full_module": "Vale.X64.Memory", "short_module": "ME" }, { "abbrev": true, "full_module": "Vale.AsLowStar.LowStarSig", "short_module": "LSig" }, { "abbrev": true, "full_module": "Vale.AsLowStar.ValeSig", "short_module": "VSig" }, { "abbrev": true, "full_module": "Vale.Interop.X64", "short_module": "IX64" }, { "abbrev": false, "full_module": "Vale.Interop.Base", "short_module": null }, { "abbrev": false, "full_module": "Vale.Def.Types_s", "short_module": null }, { "abbrev": true, "full_module": "LowStar.BufferView.Up", "short_module": "UV" }, { "abbrev": true, "full_module": "LowStar.BufferView.Down", "short_module": "DV" }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "FStar.HyperStack.ST", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 0, "max_fuel": 1, "max_ifuel": 1, "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": true, "smtencoding_l_arith_repr": "native", "smtencoding_nl_arith_repr": "wrapped", "smtencoding_valid_elim": false, "smtencoding_valid_intro": true, "tcnorm": true, "trivial_pre_for_unannotated_effectful_fns": false, "z3cliopt": [ "smt.arith.nl=false", "smt.QI.EAGER_THRESHOLD=100", "smt.CASE_SPLIT=3" ], "z3refresh": false, "z3rlimit": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_pre s iv) (Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_post s iv)	Prims.Tot	[ "total" ]	[]	[ "FStar.Ghost.erased", "FStar.Seq.Base.seq", "Vale.Def.Types_s.nat32", "Vale.AES.GCM_s.supported_iv_LE", "Vale.Stdcalls.X64.GCMdecryptOpt.as_t", "Vale.AsLowStar.ValeSig.vale_sig_stdcall", "Vale.Stdcalls.X64.GCMdecryptOpt.dom", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_pre", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_post", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_lemma'" ]	[]	false	false	false	false	false	let gcm128_lemma (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) =	as_t #(VSig.vale_sig_stdcall (gcm128_pre s iv) (gcm128_post s iv)) (gcm128_lemma' s iv)	false
Vale.Stdcalls.X64.GCMdecryptOpt.fst	Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_lemma		val gcm256_lemma : s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_pre s iv) (Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_post s iv)	let gcm256_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm256_pre s iv) (gcm256_post s iv)) (gcm256_lemma' s iv)	{ "file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCMdecryptOpt.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 173, "end_line": 372, "start_col": 0, "start_line": 372 }	module Vale.Stdcalls.X64.GCMdecryptOpt open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open FStar.Mul module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s module GC = Vale.AES.X64.GCMdecryptOpt open Vale.AES.AES_s open Vale.AES.GCM_s let uint64 = UInt64.t (* A little utility to trigger normalization in types ) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let b128 = buf_t TUInt8 TUInt128 [@__reduce__] noextract let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq [@__reduce__] noextract let t128_mod_pub = TD_Buffer TUInt8 TUInt128 ({modified=true; strict_disjointness=false; taint=MS.Public}) [@__reduce__] noextract let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) [@__reduce__] noextract let tuint64 = TD_Base TUInt64 [@__reduce__] noextract let (dom: list td{List.length dom <= 20}) = let y = [t128_no_mod; tuint64; tuint64; t128_no_mod; t128_mod_pub; t128_no_mod; t128_no_mod; t128_no_mod; t128_mod; tuint64; t128_no_mod; t128_mod; tuint64; t128_mod; tuint64; t128_mod; t128_no_mod] in assert_norm (List.length y = 17); y ( Need to rearrange the order of arguments ) [@__reduce__] noextract let gcm128_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm128_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100" [@__reduce__] noextract let gcm128_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f ( Prove that gcm128_lemma' has the required type ) noextract let gcm128_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm128_pre s iv) (gcm128_post s iv)) (gcm128_lemma' s iv) noextract let code_gcm128 = GC.va_code_Gcm_blocks_decrypt_stdcall IA.win AES_128 ( Here's the type expected for the gcm wrapper ) [@__reduce__] noextract let lowstar_gcm128_t (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.as_lowstar_sig_t_weak_stdcall code_gcm128 dom [] _ _ (W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win)) ( And here's the gcm wrapper itself ) noextract let lowstar_gcm128 (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) : lowstar_gcm128_t s iv = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.wrap_weak_stdcall code_gcm128 dom (W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win)) ( Need to rearrange the order of arguments ) [@__reduce__] noextract let gcm256_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm256_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100" [@__reduce__] noextract let gcm256_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f ( Prove that gcm256_lemma' has the required type *)	{ "checked_file": "/", "dependencies": [ "Vale.X64.State.fsti.checked", "Vale.X64.MemoryAdapters.fsti.checked", "Vale.X64.Memory.fsti.checked", "Vale.X64.Machine_s.fst.checked", "Vale.X64.Decls.fsti.checked", "Vale.Interop.X64.fsti.checked", "Vale.Interop.Base.fst.checked", "Vale.Interop.Assumptions.fst.checked", "Vale.Def.Types_s.fst.checked", "Vale.AsLowStar.Wrapper.fsti.checked", "Vale.AsLowStar.ValeSig.fst.checked", "Vale.AsLowStar.MemoryHelpers.fsti.checked", "Vale.AsLowStar.LowStarSig.fst.checked", "Vale.AES.X64.GCMdecryptOpt.fsti.checked", "Vale.AES.GCM_s.fst.checked", "Vale.AES.AES_s.fst.checked", "prims.fst.checked", "LowStar.BufferView.Up.fsti.checked", "LowStar.BufferView.Down.fsti.checked", "LowStar.Buffer.fst.checked", "FStar.UInt64.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.List.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": false, "source_file": "Vale.Stdcalls.X64.GCMdecryptOpt.fst" }	[ { "abbrev": false, "full_module": "Vale.AES.GCM_s", "short_module": null }, { "abbrev": false, "full_module": "Vale.AES.AES_s", "short_module": null }, { "abbrev": true, "full_module": "Vale.AES.X64.GCMdecryptOpt", "short_module": "GC" }, { "abbrev": true, "full_module": "Vale.X64.Machine_s", "short_module": "MS" }, { "abbrev": true, "full_module": "Vale.X64.State", "short_module": "VS" }, { "abbrev": false, "full_module": "Vale.X64.MemoryAdapters", "short_module": null }, { "abbrev": true, "full_module": "Vale.AsLowStar.Wrapper", "short_module": "W" }, { "abbrev": true, "full_module": "Vale.Interop.Assumptions", "short_module": "IA" }, { "abbrev": true, "full_module": "Vale.X64.Decls", "short_module": "V" }, { "abbrev": true, "full_module": "Vale.X64.Memory", "short_module": "ME" }, { "abbrev": true, "full_module": "Vale.AsLowStar.LowStarSig", "short_module": "LSig" }, { "abbrev": true, "full_module": "Vale.AsLowStar.ValeSig", "short_module": "VSig" }, { "abbrev": true, "full_module": "Vale.Interop.X64", "short_module": "IX64" }, { "abbrev": false, "full_module": "Vale.Interop.Base", "short_module": null }, { "abbrev": false, "full_module": "Vale.Def.Types_s", "short_module": null }, { "abbrev": true, "full_module": "LowStar.BufferView.Up", "short_module": "UV" }, { "abbrev": true, "full_module": "LowStar.BufferView.Down", "short_module": "DV" }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "FStar.HyperStack.ST", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 0, "max_fuel": 1, "max_ifuel": 1, "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": true, "smtencoding_l_arith_repr": "native", "smtencoding_nl_arith_repr": "wrapped", "smtencoding_valid_elim": false, "smtencoding_valid_intro": true, "tcnorm": true, "trivial_pre_for_unannotated_effectful_fns": false, "z3cliopt": [ "smt.arith.nl=false", "smt.QI.EAGER_THRESHOLD=100", "smt.CASE_SPLIT=3" ], "z3refresh": false, "z3rlimit": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.AsLowStar.ValeSig.vale_sig_stdcall (Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_pre s iv) (Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_post s iv)	Prims.Tot	[ "total" ]	[]	[ "FStar.Ghost.erased", "FStar.Seq.Base.seq", "Vale.Def.Types_s.nat32", "Vale.AES.GCM_s.supported_iv_LE", "Vale.Stdcalls.X64.GCMdecryptOpt.as_t", "Vale.AsLowStar.ValeSig.vale_sig_stdcall", "Vale.Stdcalls.X64.GCMdecryptOpt.dom", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_pre", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_post", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_lemma'" ]	[]	false	false	false	false	false	let gcm256_lemma (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) =	as_t #(VSig.vale_sig_stdcall (gcm256_pre s iv) (gcm256_post s iv)) (gcm256_lemma' s iv)	false
Hacl.Impl.SHA2.Core.fst	Hacl.Impl.SHA2.Core.emit4	val emit4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> hbuf: lbuffer uint8 (size (lanes a m) ! 8ul ! HD.word_len a) -> result:multibuf (lanes a m) (HD.hash_len a) -> Stack unit (requires fun h -> live_multi h result /\ live h hbuf /\ internally_disjoint result /\ disjoint_multi result hbuf) (ensures fun h0 _ h1 -> modifies_multi result h0 h1 /\ as_seq_multi h1 result == SpecVec.emit #a #m (as_seq h0 hbuf))	val emit4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> hbuf: lbuffer uint8 (size (lanes a m) ! 8ul ! HD.word_len a) -> result:multibuf (lanes a m) (HD.hash_len a) -> Stack unit (requires fun h -> live_multi h result /\ live h hbuf /\ internally_disjoint result /\ disjoint_multi result hbuf) (ensures fun h0 _ h1 -> modifies_multi result h0 h1 /\ as_seq_multi h1 result == SpecVec.emit #a #m (as_seq h0 hbuf))	let emit4 #a #m hbuf result = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 result in assert (disjoint b0 b1); assert (disjoint b0 b2); assert (disjoint b0 b3); assert (disjoint b1 b2); assert (disjoint b1 b3); assert (disjoint b2 b3); copy b0 (sub hbuf 0ul (HD.hash_len a)); copy b1 (sub hbuf (8ul ! HD.word_len a) (HD.hash_len a)); copy b2 (sub hbuf (16ul ! HD.word_len a) (HD.hash_len a)); copy b3 (sub hbuf (24ul ! HD.word_len a) (HD.hash_len a)); let h1 = ST.get() in assert (as_seq h1 b0 == LSeq.sub (as_seq h0 hbuf) 0 (hash_length a)); assert (as_seq h1 b1 == LSeq.sub (as_seq h0 hbuf) (8 word_length a) (hash_length a)); assert (as_seq h1 b2 == LSeq.sub (as_seq h0 hbuf) (16 * word_length a) (hash_length a)); assert (as_seq h1 b3 == LSeq.sub (as_seq h0 hbuf) (24 * word_length a) (hash_length a)); NTup.eq_intro (as_seq_multi h1 result) (NTup.ntup4 (as_seq h1 b0, (as_seq h1 b1, (as_seq h1 b2, as_seq h1 b3)))); assert (modifies (loc b0 \|+\| loc b1 \|+\| loc b2 \|+\| loc b3) h0 h1); assert (as_seq_multi h1 result == emit4_spec #a #m (as_seq h0 hbuf)); emit4_lemma #a #m (as_seq h0 hbuf); loc_multi4 result; assert (modifies_multi result h0 h1); ()	{ "file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 4, "end_line": 689, "start_col": 0, "start_line": 665 }	module Hacl.Impl.SHA2.Core open FStar.Mul open FStar.HyperStack open FStar.HyperStack.All open Lib.IntTypes open Lib.NTuple open Lib.Buffer open Lib.IntVector open Lib.MultiBuffer open Spec.Hash.Definitions //open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq open Hacl.Spec.SHA2.Vec module ST = FStar.HyperStack.ST module NTup = Lib.NTuple module SpecVec = Hacl.Spec.SHA2.Vec module VecTranspose = Lib.IntVector.Transpose module LSeq = Lib.Sequence module HD = Hacl.Hash.Definitions (* Force ordering in dependency analysis so that monomorphizations are inserted into the Types module first. ) let _ = Hacl.Impl.SHA2.Types.uint8_8p #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" unfold let state_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 8ul unfold let block_t (a:sha2_alg) = lbuffer uint8 (HD.block_len a) inline_for_extraction noextract let ws_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 16ul inline_for_extraction noextract val set_wsi: #a:sha2_alg -> #m:m_spec -> ws:ws_t a m -> i:size_t{v i < 16} -> b:lbuffer uint8 (HD.block_len a) -> bi:size_t{v bi < 16 / (lanes a m)} -> Stack unit (requires fun h -> live h b /\ live h ws /\ disjoint b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == LSeq.upd (as_seq h0 ws) (v i) (SpecVec.load_elementi #a #m (as_seq h0 b) (v bi))) let set_wsi #a #m ws i b bi = [@inline_let] let l = lanes a m in ws.(i) <- vec_load_be (word_t a) l (sub b (bi ! size l ! HD.word_len a) (size l ! HD.word_len a)) noextract let load_blocks_spec1 (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : ws_spec a m = let b = b.(\|0\|) in let ws0 = SpecVec.load_elementi b 0 in let ws1 = SpecVec.load_elementi b 1 in let ws2 = SpecVec.load_elementi b 2 in let ws3 = SpecVec.load_elementi b 3 in let ws4 = SpecVec.load_elementi b 4 in let ws5 = SpecVec.load_elementi b 5 in let ws6 = SpecVec.load_elementi b 6 in let ws7 = SpecVec.load_elementi b 7 in let ws8 = SpecVec.load_elementi b 8 in let ws9 = SpecVec.load_elementi b 9 in let ws10 = SpecVec.load_elementi b 10 in let ws11 = SpecVec.load_elementi b 11 in let ws12 = SpecVec.load_elementi b 12 in let ws13 = SpecVec.load_elementi b 13 in let ws14 = SpecVec.load_elementi b 14 in let ws15 = SpecVec.load_elementi b 15 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec1 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec1 b) #push-options "--z3rlimit 100" inline_for_extraction noextract val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) let load_blocks1 #a #m ib ws = let h0 = ST.get() in let b = ib.(\|0\|) in set_wsi ws 0ul b 0ul; set_wsi ws 1ul b 1ul; set_wsi ws 2ul b 2ul; set_wsi ws 3ul b 3ul; set_wsi ws 4ul b 4ul; set_wsi ws 5ul b 5ul; set_wsi ws 6ul b 6ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b 7ul; set_wsi ws 8ul b 8ul; set_wsi ws 9ul b 9ul; set_wsi ws 10ul b 10ul; set_wsi ws 11ul b 11ul; set_wsi ws 12ul b 12ul; set_wsi ws 13ul b 13ul; set_wsi ws 14ul b 14ul; set_wsi ws 15ul b 15ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib)); load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)) #pop-options noextract let load_blocks_spec4 (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b0 1 in let ws5 = SpecVec.load_elementi b1 1 in let ws6 = SpecVec.load_elementi b2 1 in let ws7 = SpecVec.load_elementi b3 1 in let ws8 = SpecVec.load_elementi b0 2 in let ws9 = SpecVec.load_elementi b1 2 in let ws10 = SpecVec.load_elementi b2 2 in let ws11 = SpecVec.load_elementi b3 2 in let ws12 = SpecVec.load_elementi b0 3 in let ws13 = SpecVec.load_elementi b1 3 in let ws14 = SpecVec.load_elementi b2 3 in let ws15 = SpecVec.load_elementi b3 3 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec4_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec4 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec4 b) inline_for_extraction noextract val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) #push-options "--z3rlimit 150" let load_blocks4 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b0 1ul; set_wsi ws 5ul b1 1ul; set_wsi ws 6ul b2 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b3 1ul; set_wsi ws 8ul b0 2ul; set_wsi ws 9ul b1 2ul; set_wsi ws 10ul b2 2ul; set_wsi ws 11ul b3 2ul; set_wsi ws 12ul b0 3ul; set_wsi ws 13ul b1 3ul; set_wsi ws 14ul b2 3ul; set_wsi ws 15ul b3 3ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec4 (as_seq_multi h0 ib)); load_blocks_spec4_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec4 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); () #pop-options noextract let load_blocks_spec8 (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let b4 = b.(\|4\|) in let b5 = b.(\|5\|) in let b6 = b.(\|6\|) in let b7 = b.(\|7\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b4 0 in let ws5 = SpecVec.load_elementi b5 0 in let ws6 = SpecVec.load_elementi b6 0 in let ws7 = SpecVec.load_elementi b7 0 in let ws8 = SpecVec.load_elementi b0 1 in let ws9 = SpecVec.load_elementi b1 1 in let ws10 = SpecVec.load_elementi b2 1 in let ws11 = SpecVec.load_elementi b3 1 in let ws12 = SpecVec.load_elementi b4 1 in let ws13 = SpecVec.load_elementi b5 1 in let ws14 = SpecVec.load_elementi b6 1 in let ws15 = SpecVec.load_elementi b7 1 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec8_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec8 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec8 b) inline_for_extraction noextract val load_blocks8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) #push-options "--z3rlimit 150" let load_blocks8 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,(b3,(b4,(b5,(b6,b7))))))) = NTup.tup8 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b4 0ul; set_wsi ws 5ul b5 0ul; set_wsi ws 6ul b6 0ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b7 0ul; set_wsi ws 8ul b0 1ul; set_wsi ws 9ul b1 1ul; set_wsi ws 10ul b2 1ul; set_wsi ws 11ul b3 1ul; set_wsi ws 12ul b4 1ul; set_wsi ws 13ul b5 1ul; set_wsi ws 14ul b6 1ul; set_wsi ws 15ul b7 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec8 (as_seq_multi h0 ib)); load_blocks_spec8_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec8 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); () #pop-options inline_for_extraction noextract val load_blocks: #a:sha2_alg -> #m:m_spec{is_supported a m} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) let load_blocks #a #m b ws = match lanes a m with \| 1 -> load_blocks1 b ws \| 4 -> load_blocks4 b ws \| 8 -> load_blocks8 b ws inline_for_extraction noextract val transpose_ws4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws4 #a #m ws = let (ws0,ws1,ws2,ws3) = VecTranspose.transpose4x4 (ws.(0ul),ws.(1ul),ws.(2ul),ws.(3ul)) in let (ws4,ws5,ws6,ws7) = VecTranspose.transpose4x4 (ws.(4ul),ws.(5ul),ws.(6ul),ws.(7ul)) in let (ws8,ws9,ws10,ws11) = VecTranspose.transpose4x4 (ws.(8ul),ws.(9ul),ws.(10ul),ws.(11ul)) in let (ws12,ws13,ws14,ws15) = VecTranspose.transpose4x4 (ws.(12ul),ws.(13ul),ws.(14ul),ws.(15ul)) in create16 ws ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 inline_for_extraction noextract val transpose_ws8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws8 #a #m ws = let (ws0,ws1,ws2,ws3,ws4,ws5,ws6,ws7) = VecTranspose.transpose8x8 (ws.(0ul),ws.(1ul),ws.(2ul),ws.(3ul),ws.(4ul),ws.(5ul),ws.(6ul),ws.(7ul)) in let (ws8,ws9,ws10,ws11,ws12,ws13,ws14,ws15) = VecTranspose.transpose8x8 (ws.(8ul),ws.(9ul),ws.(10ul),ws.(11ul),ws.(12ul),ws.(13ul),ws.(14ul),ws.(15ul)) in create16 ws ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 inline_for_extraction noextract val transpose_ws: #a:sha2_alg -> #m:m_spec{is_supported a m} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws #a #m ws = match lanes a m with \| 1 -> () \| 4 -> transpose_ws4 ws \| 8 -> transpose_ws8 ws inline_for_extraction noextract val load_ws: #a:sha2_alg -> #m:m_spec{is_supported a m} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_ws #a #m (as_seq_multi h0 b)) let load_ws #a #m b ws = load_blocks b ws; transpose_ws ws inline_for_extraction noextract let padded_blocks (a:sha2_alg) (len:size_t{v len <= block_length a}) : n:size_t{v n == SpecVec.padded_blocks a (v len)} = if (len +! len_len a +! 1ul <=. HD.block_len a) then 1ul else 2ul inline_for_extraction noextract val load_last_blocks: #a:sha2_alg -> totlen_buf:lbuffer uint8 (len_len a) -> len:size_t{v len <= block_length a} -> b:lbuffer uint8 len -> fin:size_t{v fin == block_length a \/ v fin == 2 * block_length a} -> last:lbuffer uint8 (2ul ! HD.block_len a) -> Stack (lbuffer uint8 (HD.block_len a) & lbuffer uint8 (HD.block_len a)) (requires fun h -> live h totlen_buf /\ live h b /\ live h last /\ disjoint b last /\ disjoint last totlen_buf /\ as_seq h last == LSeq.create (2 block_length a) (u8 0)) (ensures (fun h0 (l0,l1) h1 -> modifies (loc last) h0 h1 /\ live h1 l0 /\ live h1 l1 /\ (forall a l (r:lbuffer a l). disjoint last r ==> (disjoint l0 r /\ disjoint l1 r)) /\ (as_seq h1 l0, as_seq h1 l1) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b))) #push-options "--z3rlimit 200" let load_last_blocks #a totlen_buf len b fin last = let h0 = ST.get() in update_sub last 0ul len b; last.(len) <- u8 0x80; update_sub last (fin -. len_len a) (len_len a) totlen_buf; let last0 : lbuffer uint8 (HD.block_len a) = sub last 0ul (HD.block_len a) in let last1 : lbuffer uint8 (HD.block_len a) = sub last (HD.block_len a) (HD.block_len a) in let h1 = ST.get() in assert (modifies (loc last) h0 h1); (last0,last1) #pop-options noextract let preserves_sub_disjoint_multi #lanes #len #len' (b:lbuffer uint8 len) (r:multibuf lanes len') = (forall a l (x:lbuffer a l). disjoint b x ==> disjoint_multi r x) inline_for_extraction noextract let load_last_t (a:sha2_alg) (m:m_spec{is_supported a m}) = totlen_buf:lbuffer uint8 (len_len a) -> len:size_t{v len <= block_length a} -> b:multibuf (lanes a m) len -> fin:size_t{v fin == block_length a \/ v fin == 2 * block_length a} -> last:lbuffer uint8 (size (lanes a m) ! 2ul ! HD.block_len a) -> Stack (multibuf (lanes a m) (HD.block_len a) & multibuf (lanes a m) (HD.block_len a)) (requires fun h -> live h totlen_buf /\ live_multi h b /\ live h last /\ disjoint_multi b last /\ disjoint last totlen_buf /\ as_seq h last == LSeq.create (lanes a m * 2 * block_length a) (u8 0)) (ensures fun h0 (l0,l1) h1 -> modifies (loc last) h0 h1 /\ live_multi h1 l0 /\ live_multi h1 l1 /\ preserves_sub_disjoint_multi last l0 /\ preserves_sub_disjoint_multi last l1 /\ (as_seq_multi h1 l0, as_seq_multi h1 l1) == SpecVec.load_last #a #m (as_seq h0 totlen_buf) (v fin) (v len) (as_seq_multi h0 b)) inline_for_extraction noextract val load_last1: #a:sha2_alg -> #m:m_spec{lanes a m = 1} -> load_last_t a m #push-options "--z3rlimit 250" let load_last1 #a #m totlen_buf len b fin last = let h0 = ST.get() in let b0 = b.(\|0\|) in let (l0,l1) = load_last_blocks #a totlen_buf len b0 fin last in let lb0 : multibuf (lanes a m) (HD.block_len a) = ntup1 l0 in let lb1 : multibuf (lanes a m) (HD.block_len a) = ntup1 l1 in let h1 = ST.get() in assert (modifies (loc last) h0 h1); NTup.eq_intro (as_seq_multi h0 b) (ntup1 (as_seq h0 b0)); NTup.eq_intro (as_seq_multi h1 lb0) (ntup1 (as_seq h1 l0)); NTup.eq_intro (as_seq_multi h1 lb1) (ntup1 (as_seq h1 l1)); assert ((as_seq_multi h1 lb0, as_seq_multi h1 lb1) == SpecVec.load_last1 #a #m (as_seq h0 totlen_buf) (v fin) (v len) (as_seq_multi h0 b)); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (lb0,lb1) #pop-options inline_for_extraction noextract val load_last4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> load_last_t a m #push-options "--z3rlimit 350" let load_last4 #a #m totlen_buf len b fin last = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 b in let last0 = sub last 0ul (2ul ! HD.block_len a) in let last1 = sub last (2ul ! HD.block_len a) (2ul ! HD.block_len a) in let last2 = sub last (4ul ! HD.block_len a) (2ul ! HD.block_len a) in let last3 = sub last (6ul ! HD.block_len a) (2ul ! HD.block_len a) in let h1 = ST.get() in assert (disjoint last0 last1); LSeq.eq_intro (as_seq h1 last0) (LSeq.create (2 block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last1) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last2) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last3) (LSeq.create (2 * block_length a) (u8 0)); let (l00,l01) = load_last_blocks #a totlen_buf len b0 fin last0 in let (l10,l11) = load_last_blocks #a totlen_buf len b1 fin last1 in let (l20,l21) = load_last_blocks #a totlen_buf len b2 fin last2 in let (l30,l31) = load_last_blocks #a totlen_buf len b3 fin last3 in let mb0:multibuf (lanes a m) (HD.block_len a) = ntup4 (l00, (l10, (l20, l30))) in let mb1:multibuf (lanes a m) (HD.block_len a) = ntup4 (l01, (l11, (l21, l31))) in let h1 = ST.get() in assert ((as_seq h1 l00, as_seq h1 l01) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b0)); assert ((as_seq h1 l10, as_seq h1 l11) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b1)); assert ((as_seq h1 l20, as_seq h1 l21) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b2)); assert ((as_seq h1 l30, as_seq h1 l31) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b3)); NTup.eq_intro (as_seq_multi h1 mb0) (ntup4 (as_seq h1 l00, (as_seq h1 l10, (as_seq h1 l20, (as_seq h1 l30))))); NTup.eq_intro (as_seq_multi h1 mb1) (ntup4 (as_seq h1 l01, (as_seq h1 l11, (as_seq h1 l21, (as_seq h1 l31))))); assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3) h0 h1); assert (modifies (loc last) h0 h1); assert (live_multi h1 mb0); assert (live_multi h1 mb1); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (mb0, mb1) #pop-options inline_for_extraction noextract val load_last8: #a:sha2_alg -> #m:m_spec{lanes a m = 8} -> load_last_t a m #push-options "--z3rlimit 600" let load_last8 #a #m totlen_buf len b fin last = let h0 = ST.get() in let (b0,(b1,(b2,(b3,(b4,(b5,(b6,b7))))))) = NTup.tup8 b in let last0 = sub last 0ul (2ul ! HD.block_len a) in let last1 = sub last (2ul ! HD.block_len a) (2ul ! HD.block_len a) in let last2 = sub last (4ul ! HD.block_len a) (2ul ! HD.block_len a) in let last3 = sub last (6ul ! HD.block_len a) (2ul ! HD.block_len a) in let last4 = sub last (8ul ! HD.block_len a) (2ul ! HD.block_len a) in let last5 = sub last (10ul ! HD.block_len a) (2ul ! HD.block_len a) in let last6 = sub last (12ul ! HD.block_len a) (2ul ! HD.block_len a) in let last7 = sub last (14ul ! HD.block_len a) (2ul ! HD.block_len a) in assert (internally_disjoint8 last0 last1 last2 last3 last4 last5 last6 last7); let h1 = ST.get() in assert (h0 == h1); LSeq.eq_intro (as_seq h1 last0) (LSeq.create (2 block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last1) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last2) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last3) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last4) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last5) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last6) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last7) (LSeq.create (2 * block_length a) (u8 0)); let (l00,l01) = load_last_blocks #a totlen_buf len b0 fin last0 in let (l10,l11) = load_last_blocks #a totlen_buf len b1 fin last1 in let h2 = ST.get() in assert (modifies (loc last0 \|+\| loc last1) h0 h2); let (l20,l21) = load_last_blocks #a totlen_buf len b2 fin last2 in let (l30,l31) = load_last_blocks #a totlen_buf len b3 fin last3 in let h2 = ST.get() in assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3) h0 h2); let (l40,l41) = load_last_blocks #a totlen_buf len b4 fin last4 in let (l50,l51) = load_last_blocks #a totlen_buf len b5 fin last5 in let h2 = ST.get() in assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3 \|+\| loc last4 \|+\| loc last5) h0 h2); let (l60,l61) = load_last_blocks #a totlen_buf len b6 fin last6 in let (l70,l71) = load_last_blocks #a totlen_buf len b7 fin last7 in let h3 = ST.get() in assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3 \|+\| loc last4 \|+\| loc last5 \|+\| loc last6 \|+\| loc last7) h0 h3); assert (modifies (loc last) h0 h3); let mb0:multibuf (lanes a m) (HD.block_len a) = ntup8 (l00, (l10, (l20, (l30, (l40, (l50, (l60, l70))))))) in let mb1:multibuf (lanes a m) (HD.block_len a) = ntup8 (l01, (l11, (l21, (l31, (l41, (l51, (l61, l71))))))) in ntup8_lemma #_ #8 (l00, (l10, (l20, (l30, (l40, (l50, (l60, l70))))))); ntup8_lemma #_ #8 (l01, (l11, (l21, (l31, (l41, (l51, (l61, l71))))))); assert (live_multi h3 mb0); assert (live_multi h3 mb1); NTup.eq_intro (as_seq_multi h3 mb0) (ntup8 (as_seq h3 l00, (as_seq h3 l10, (as_seq h3 l20, (as_seq h3 l30, (as_seq h3 l40, (as_seq h3 l50, (as_seq h3 l60, (as_seq h3 l70))))))))); NTup.eq_intro (as_seq_multi h3 mb1) (ntup8 (as_seq h3 l01, (as_seq h3 l11, (as_seq h3 l21, (as_seq h3 l31, (as_seq h3 l41, (as_seq h3 l51, (as_seq h3 l61, (as_seq h3 l71))))))))); assert ((as_seq_multi h3 mb0, as_seq_multi h3 mb1) == SpecVec.load_last8 #a #m (as_seq h0 totlen_buf) (v fin) (v len) (as_seq_multi h0 b)); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (mb0, mb1) #pop-options inline_for_extraction noextract val load_last: #a:sha2_alg -> #m:m_spec{is_supported a m} -> load_last_t a m let load_last #a #m totlen_buf len b fin last = match lanes a m with \| 1 -> load_last1 #a #m totlen_buf len b fin last \| 4 -> load_last4 #a #m totlen_buf len b fin last \| 8 -> load_last8 #a #m totlen_buf len b fin last inline_for_extraction noextract val transpose_state4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> st:state_t a m -> Stack unit (requires fun h -> live h st) (ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\ as_seq h1 st == SpecVec.transpose_state4 (as_seq h0 st)) let transpose_state4 #a #m st = let (st0',st1',st2',st3') = VecTranspose.transpose4x4 (st.(0ul),st.(1ul),st.(2ul),st.(3ul)) in let (st4',st5',st6',st7') = VecTranspose.transpose4x4 (st.(4ul),st.(5ul),st.(6ul),st.(7ul)) in create8 st st0' st4' st1' st5' st2' st6' st3' st7' inline_for_extraction noextract val transpose_state8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> st:state_t a m -> Stack unit (requires fun h -> live h st) (ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\ as_seq h1 st == SpecVec.transpose_state8 (as_seq h0 st)) let transpose_state8 #a #m st = let (st0',st1',st2',st3',st4',st5',st6',st7') = VecTranspose.transpose8x8 (st.(0ul),st.(1ul),st.(2ul),st.(3ul),st.(4ul),st.(5ul),st.(6ul),st.(7ul)) in create8 st st0' st1' st2' st3' st4' st5' st6' st7' inline_for_extraction noextract val transpose_state: #a:sha2_alg -> #m:m_spec{is_supported a m} -> st:state_t a m -> Stack unit (requires fun h -> live h st) (ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\ as_seq h1 st == SpecVec.transpose_state (as_seq h0 st)) let transpose_state #a #m st = match lanes a m with \| 1 -> () \| 4 -> transpose_state4 st \| 8 -> transpose_state8 st inline_for_extraction noextract val store_state: #a:sha2_alg -> #m:m_spec{is_supported a m} -> st:state_t a m -> hbuf:lbuffer uint8 (size (lanes a m) ! 8ul ! HD.word_len a) -> Stack unit (requires fun h -> live h hbuf /\ live h st /\ disjoint hbuf st /\ as_seq h hbuf == LSeq.create (lanes a m * 8 * word_length a) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc st \|+\| loc hbuf) h0 h1 /\ as_seq h1 hbuf == SpecVec.store_state #a #m (as_seq h0 st)) let store_state #a #m st hbuf = transpose_state st; Lib.IntVector.Serialize.vecs_store_be hbuf st noextract let emit1_spec (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (hseq:LSeq.lseq uint8 (lanes a m * 8 * word_length a)) : multiseq (lanes a m) (hash_length a) = let hsub = LSeq.sub hseq 0 (hash_length a) in ntup1 hsub noextract let emit1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (hseq:LSeq.lseq uint8 (lanes a m * 8 * word_length a)) : Lemma (emit1_spec #a #m hseq == SpecVec.emit #a #m hseq) = Lib.NTuple.eq_intro (emit1_spec #a #m hseq) (SpecVec.emit #a #m hseq) inline_for_extraction noextract val emit1: #a:sha2_alg -> #m:m_spec{lanes a m = 1} -> hbuf:lbuffer uint8 (8ul ! HD.word_len a) -> result:multibuf (lanes a m) (HD.hash_len a) -> Stack unit (requires fun h -> live_multi h result /\ live h hbuf /\ internally_disjoint result /\ disjoint_multi result hbuf) (ensures fun h0 _ h1 -> modifies_multi result h0 h1 /\ as_seq_multi h1 result == SpecVec.emit #a #m (as_seq h0 hbuf)) let emit1 #a #m hbuf result = let h0 = ST.get() in copy result.(\|0\|) (sub hbuf 0ul (HD.hash_len a)); let h1 = ST.get() in Lib.NTuple.eq_intro (as_seq_multi h1 result) (emit1_spec #a #m (as_seq h0 hbuf)); emit1_lemma #a #m (as_seq h0 hbuf); assert (modifies_multi result h0 h1) noextract let emit4_spec (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (hseq:LSeq.lseq uint8 (lanes a m 8 * word_length a)) : multiseq (lanes a m) (hash_length a) = let open Lib.Sequence in let h0 = sub hseq 0 (hash_length a) in let h1 = sub hseq (8 * word_length a) (hash_length a) in let h2 = sub hseq (16 * word_length a) (hash_length a) in let h3 = sub hseq (24 * word_length a) (hash_length a) in let hsub : multiseq 4 (hash_length a) = ntup4 (h0,(h1,(h2,h3))) in hsub noextract let emit4_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (hseq:LSeq.lseq uint8 (lanes a m * 8 * word_length a)) : Lemma (emit4_spec #a #m hseq == SpecVec.emit #a #m hseq) = Lib.NTuple.eq_intro (emit4_spec #a #m hseq) (SpecVec.emit #a #m hseq) inline_for_extraction noextract val emit4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> hbuf: lbuffer uint8 (size (lanes a m) ! 8ul ! HD.word_len a) -> result:multibuf (lanes a m) (HD.hash_len a) -> Stack unit (requires fun h -> live_multi h result /\ live h hbuf /\ internally_disjoint result /\ disjoint_multi result hbuf) (ensures fun h0 _ h1 -> modifies_multi result h0 h1 /\ as_seq_multi h1 result == SpecVec.emit #a #m (as_seq h0 hbuf))	{ "checked_file": "/", "dependencies": [ "Spec.Hash.Definitions.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.NTuple.fsti.checked", "Lib.MultiBuffer.fst.checked", "Lib.IntVector.Transpose.fsti.checked", "Lib.IntVector.Serialize.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Lib.Buffer.fsti.checked", "Hacl.Spec.SHA2.Vec.fst.checked", "Hacl.Impl.SHA2.Types.fst.checked", "Hacl.Hash.Definitions.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.All.fst.checked", "FStar.HyperStack.fst.checked" ], "interface_file": false, "source_file": "Hacl.Impl.SHA2.Core.fst" }	[ { "abbrev": true, "full_module": "Hacl.Hash.Definitions", "short_module": "HD" }, { "abbrev": true, "full_module": "Lib.Sequence", "short_module": "LSeq" }, { "abbrev": true, "full_module": "Lib.IntVector.Transpose", "short_module": "VecTranspose" }, { "abbrev": true, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": "SpecVec" }, { "abbrev": true, "full_module": "Lib.NTuple", "short_module": "NTup" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "ST" }, { "abbrev": false, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": null }, { "abbrev": false, "full_module": "Spec.Hash.Definitions", "short_module": null }, { "abbrev": false, "full_module": "Lib.MultiBuffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.Buffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.NTuple", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack.All", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "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 } ]	{ "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": 200, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	hbuf: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Lib.IntTypes.size (Hacl.Spec.SHA2.Vec.lanes a m) ! 8ul ! Hacl.Hash.Definitions.word_len a ) -> result: Lib.MultiBuffer.multibuf (Hacl.Spec.SHA2.Vec.lanes a m) (Hacl.Hash.Definitions.hash_len a) -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Spec.Hash.Definitions.sha2_alg", "Hacl.Spec.SHA2.Vec.m_spec", "Prims.b2t", "Prims.op_Equality", "Prims.int", "Hacl.Spec.SHA2.Vec.lanes", "Lib.Buffer.lbuffer", "Lib.IntTypes.uint8", "Lib.IntTypes.op_Star_Bang", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "Lib.IntTypes.size", "FStar.UInt32.__uint_to_t", "Hacl.Hash.Definitions.word_len", "Lib.MultiBuffer.multibuf", "Hacl.Hash.Definitions.hash_len", "Prims.unit", "Prims._assert", "Lib.MultiBuffer.modifies_multi", "Lib.MultiBuffer.loc_multi4", "Hacl.Impl.SHA2.Core.emit4_lemma", "Lib.Buffer.as_seq", "Lib.Buffer.MUT", "Prims.eq2", "Lib.NTuple.ntuple", "FStar.Seq.Properties.lseq", "Spec.Hash.Definitions.hash_length", "Lib.MultiBuffer.as_seq_multi", "Hacl.Impl.SHA2.Core.emit4_spec", "Lib.Buffer.modifies", "Lib.Buffer.op_Bar_Plus_Bar", "Lib.Buffer.loc", "Lib.NTuple.eq_intro", "Lib.IntTypes.v", "Lib.NTuple.ntup4", "FStar.Pervasives.Native.Mktuple2", "FStar.Pervasives.Native.tuple2", "Lib.Sequence.seq", "Prims.l_or", "Prims.l_and", "Prims.nat", "FStar.Seq.Base.length", "FStar.Seq.Base.seq", "Lib.Sequence.to_seq", "FStar.Seq.Base.slice", "FStar.Mul.op_Star", "Spec.Hash.Definitions.word_length", "Prims.op_Addition", "Prims.l_Forall", "Prims.op_LessThan", "FStar.Seq.Base.index", "Lib.Sequence.index", "Lib.Sequence.sub", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Lib.Buffer.copy", "Lib.Buffer.lbuffer_t", "Lib.IntTypes.int_t", "Lib.IntTypes.U8", "Lib.IntTypes.SEC", "Lib.Buffer.sub", "Lib.Buffer.disjoint", "Lib.NTuple.tup4" ]	[]	false	true	false	false	false	let emit4 #a #m hbuf result =	let h0 = ST.get () in let b0, (b1, (b2, b3)) = NTup.tup4 result in assert (disjoint b0 b1); assert (disjoint b0 b2); assert (disjoint b0 b3); assert (disjoint b1 b2); assert (disjoint b1 b3); assert (disjoint b2 b3); copy b0 (sub hbuf 0ul (HD.hash_len a)); copy b1 (sub hbuf (8ul ! HD.word_len a) (HD.hash_len a)); copy b2 (sub hbuf (16ul ! HD.word_len a) (HD.hash_len a)); copy b3 (sub hbuf (24ul ! HD.word_len a) (HD.hash_len a)); let h1 = ST.get () in assert (as_seq h1 b0 == LSeq.sub (as_seq h0 hbuf) 0 (hash_length a)); assert (as_seq h1 b1 == LSeq.sub (as_seq h0 hbuf) (8 word_length a) (hash_length a)); assert (as_seq h1 b2 == LSeq.sub (as_seq h0 hbuf) (16 * word_length a) (hash_length a)); assert (as_seq h1 b3 == LSeq.sub (as_seq h0 hbuf) (24 * word_length a) (hash_length a)); NTup.eq_intro (as_seq_multi h1 result) (NTup.ntup4 (as_seq h1 b0, (as_seq h1 b1, (as_seq h1 b2, as_seq h1 b3)))); assert (modifies (loc b0 \|+\| loc b1 \|+\| loc b2 \|+\| loc b3) h0 h1); assert (as_seq_multi h1 result == emit4_spec #a #m (as_seq h0 hbuf)); emit4_lemma #a #m (as_seq h0 hbuf); loc_multi4 result; assert (modifies_multi result h0 h1); ()	false
Steel.Closure.fsti	Steel.Closure.ctr_t		val ctr_t : Type	let ctr_t = (p:(int -> vprop) & (x:erased int -> SteelT (y:int{y == x + 1}) (p x) p))	{ "file_name": "lib/steel/Steel.Closure.fsti", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }	{ "end_col": 85, "end_line": 25, "start_col": 0, "start_line": 25 }	(* Copyright 2020 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. *) module Steel.Closure open Steel.Memory open Steel.Effect open FStar.Ghost /// A small proof-of-concept library showing that vprops can be used inside closures	{ "checked_file": "/", "dependencies": [ "Steel.Memory.fsti.checked", "Steel.Effect.fsti.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Ghost.fsti.checked" ], "interface_file": false, "source_file": "Steel.Closure.fsti" }	[ { "abbrev": false, "full_module": "FStar.Ghost", "short_module": null }, { "abbrev": false, "full_module": "Steel.Effect", "short_module": null }, { "abbrev": false, "full_module": "Steel.Memory", "short_module": null }, { "abbrev": false, "full_module": "Steel", "short_module": null }, { "abbrev": false, "full_module": "Steel", "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 } ]	{ "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" }	false	Type	Prims.Tot	[ "total" ]	[]	[ "Prims.dtuple2", "Prims.int", "Steel.Effect.Common.vprop", "FStar.Ghost.erased", "Prims.eq2", "Prims.op_Addition", "FStar.Ghost.reveal" ]	[]	false	false	false	true	true	let ctr_t =	(p: (int -> vprop) & (x: erased int -> SteelT (y: int{y == x + 1}) (p x) p))	false
Hacl.Impl.SHA2.Core.fst	Hacl.Impl.SHA2.Core.load_blocks8	val load_blocks8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	val load_blocks8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	let load_blocks8 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,(b3,(b4,(b5,(b6,b7))))))) = NTup.tup8 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b4 0ul; set_wsi ws 5ul b5 0ul; set_wsi ws 6ul b6 0ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b7 0ul; set_wsi ws 8ul b0 1ul; set_wsi ws 9ul b1 1ul; set_wsi ws 10ul b2 1ul; set_wsi ws 11ul b3 1ul; set_wsi ws 12ul b4 1ul; set_wsi ws 13ul b5 1ul; set_wsi ws 14ul b6 1ul; set_wsi ws 15ul b7 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec8 (as_seq_multi h0 ib)); load_blocks_spec8_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec8 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); ()	{ "file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 4, "end_line": 277, "start_col": 0, "start_line": 250 }	module Hacl.Impl.SHA2.Core open FStar.Mul open FStar.HyperStack open FStar.HyperStack.All open Lib.IntTypes open Lib.NTuple open Lib.Buffer open Lib.IntVector open Lib.MultiBuffer open Spec.Hash.Definitions //open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq open Hacl.Spec.SHA2.Vec module ST = FStar.HyperStack.ST module NTup = Lib.NTuple module SpecVec = Hacl.Spec.SHA2.Vec module VecTranspose = Lib.IntVector.Transpose module LSeq = Lib.Sequence module HD = Hacl.Hash.Definitions (* Force ordering in dependency analysis so that monomorphizations are inserted into the Types module first. ) let _ = Hacl.Impl.SHA2.Types.uint8_8p #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" unfold let state_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 8ul unfold let block_t (a:sha2_alg) = lbuffer uint8 (HD.block_len a) inline_for_extraction noextract let ws_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 16ul inline_for_extraction noextract val set_wsi: #a:sha2_alg -> #m:m_spec -> ws:ws_t a m -> i:size_t{v i < 16} -> b:lbuffer uint8 (HD.block_len a) -> bi:size_t{v bi < 16 / (lanes a m)} -> Stack unit (requires fun h -> live h b /\ live h ws /\ disjoint b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == LSeq.upd (as_seq h0 ws) (v i) (SpecVec.load_elementi #a #m (as_seq h0 b) (v bi))) let set_wsi #a #m ws i b bi = [@inline_let] let l = lanes a m in ws.(i) <- vec_load_be (word_t a) l (sub b (bi ! size l ! HD.word_len a) (size l ! HD.word_len a)) noextract let load_blocks_spec1 (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : ws_spec a m = let b = b.(\|0\|) in let ws0 = SpecVec.load_elementi b 0 in let ws1 = SpecVec.load_elementi b 1 in let ws2 = SpecVec.load_elementi b 2 in let ws3 = SpecVec.load_elementi b 3 in let ws4 = SpecVec.load_elementi b 4 in let ws5 = SpecVec.load_elementi b 5 in let ws6 = SpecVec.load_elementi b 6 in let ws7 = SpecVec.load_elementi b 7 in let ws8 = SpecVec.load_elementi b 8 in let ws9 = SpecVec.load_elementi b 9 in let ws10 = SpecVec.load_elementi b 10 in let ws11 = SpecVec.load_elementi b 11 in let ws12 = SpecVec.load_elementi b 12 in let ws13 = SpecVec.load_elementi b 13 in let ws14 = SpecVec.load_elementi b 14 in let ws15 = SpecVec.load_elementi b 15 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec1 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec1 b) #push-options "--z3rlimit 100" inline_for_extraction noextract val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) let load_blocks1 #a #m ib ws = let h0 = ST.get() in let b = ib.(\|0\|) in set_wsi ws 0ul b 0ul; set_wsi ws 1ul b 1ul; set_wsi ws 2ul b 2ul; set_wsi ws 3ul b 3ul; set_wsi ws 4ul b 4ul; set_wsi ws 5ul b 5ul; set_wsi ws 6ul b 6ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b 7ul; set_wsi ws 8ul b 8ul; set_wsi ws 9ul b 9ul; set_wsi ws 10ul b 10ul; set_wsi ws 11ul b 11ul; set_wsi ws 12ul b 12ul; set_wsi ws 13ul b 13ul; set_wsi ws 14ul b 14ul; set_wsi ws 15ul b 15ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib)); load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)) #pop-options noextract let load_blocks_spec4 (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b0 1 in let ws5 = SpecVec.load_elementi b1 1 in let ws6 = SpecVec.load_elementi b2 1 in let ws7 = SpecVec.load_elementi b3 1 in let ws8 = SpecVec.load_elementi b0 2 in let ws9 = SpecVec.load_elementi b1 2 in let ws10 = SpecVec.load_elementi b2 2 in let ws11 = SpecVec.load_elementi b3 2 in let ws12 = SpecVec.load_elementi b0 3 in let ws13 = SpecVec.load_elementi b1 3 in let ws14 = SpecVec.load_elementi b2 3 in let ws15 = SpecVec.load_elementi b3 3 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec4_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec4 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec4 b) inline_for_extraction noextract val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) #push-options "--z3rlimit 150" let load_blocks4 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b0 1ul; set_wsi ws 5ul b1 1ul; set_wsi ws 6ul b2 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b3 1ul; set_wsi ws 8ul b0 2ul; set_wsi ws 9ul b1 2ul; set_wsi ws 10ul b2 2ul; set_wsi ws 11ul b3 2ul; set_wsi ws 12ul b0 3ul; set_wsi ws 13ul b1 3ul; set_wsi ws 14ul b2 3ul; set_wsi ws 15ul b3 3ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec4 (as_seq_multi h0 ib)); load_blocks_spec4_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec4 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); () #pop-options noextract let load_blocks_spec8 (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let b4 = b.(\|4\|) in let b5 = b.(\|5\|) in let b6 = b.(\|6\|) in let b7 = b.(\|7\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b4 0 in let ws5 = SpecVec.load_elementi b5 0 in let ws6 = SpecVec.load_elementi b6 0 in let ws7 = SpecVec.load_elementi b7 0 in let ws8 = SpecVec.load_elementi b0 1 in let ws9 = SpecVec.load_elementi b1 1 in let ws10 = SpecVec.load_elementi b2 1 in let ws11 = SpecVec.load_elementi b3 1 in let ws12 = SpecVec.load_elementi b4 1 in let ws13 = SpecVec.load_elementi b5 1 in let ws14 = SpecVec.load_elementi b6 1 in let ws15 = SpecVec.load_elementi b7 1 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec8_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec8 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec8 b) inline_for_extraction noextract val load_blocks8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	{ "checked_file": "/", "dependencies": [ "Spec.Hash.Definitions.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.NTuple.fsti.checked", "Lib.MultiBuffer.fst.checked", "Lib.IntVector.Transpose.fsti.checked", "Lib.IntVector.Serialize.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Lib.Buffer.fsti.checked", "Hacl.Spec.SHA2.Vec.fst.checked", "Hacl.Impl.SHA2.Types.fst.checked", "Hacl.Hash.Definitions.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.All.fst.checked", "FStar.HyperStack.fst.checked" ], "interface_file": false, "source_file": "Hacl.Impl.SHA2.Core.fst" }	[ { "abbrev": true, "full_module": "Hacl.Hash.Definitions", "short_module": "HD" }, { "abbrev": true, "full_module": "Lib.Sequence", "short_module": "LSeq" }, { "abbrev": true, "full_module": "Lib.IntVector.Transpose", "short_module": "VecTranspose" }, { "abbrev": true, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": "SpecVec" }, { "abbrev": true, "full_module": "Lib.NTuple", "short_module": "NTup" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "ST" }, { "abbrev": false, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": null }, { "abbrev": false, "full_module": "Spec.Hash.Definitions", "short_module": null }, { "abbrev": false, "full_module": "Lib.MultiBuffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.Buffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.NTuple", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack.All", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "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 } ]	{ "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": 150, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	b: Lib.MultiBuffer.multibuf (Hacl.Spec.SHA2.Vec.lanes a m) (Hacl.Hash.Definitions.block_len a) -> ws: Hacl.Impl.SHA2.Core.ws_t a m -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Spec.Hash.Definitions.sha2_alg", "Hacl.Spec.SHA2.Vec.m_spec", "Prims.eq2", "Prims.int", "Hacl.Spec.SHA2.Vec.lanes", "Lib.MultiBuffer.multibuf", "Hacl.Hash.Definitions.block_len", "Hacl.Impl.SHA2.Core.ws_t", "Lib.Buffer.lbuffer", "Lib.IntTypes.uint8", "Prims.unit", "Prims._assert", "Lib.Sequence.lseq", "Hacl.Spec.SHA2.Vec.element_t", "Lib.Buffer.as_seq", "Lib.Buffer.MUT", "FStar.UInt32.__uint_to_t", "Hacl.Spec.SHA2.Vec.load_blocks", "Lib.MultiBuffer.as_seq_multi", "Lib.IntTypes.v", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "Hacl.Impl.SHA2.Core.load_blocks_spec8", "Hacl.Impl.SHA2.Core.load_blocks_spec8_lemma", "Lib.Sequence.eq_intro", "Lib.Buffer.modifies", "Lib.Buffer.loc", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Hacl.Impl.SHA2.Core.set_wsi", "FStar.Pervasives.Native.tuple2", "Lib.Buffer.lbuffer_t", "Lib.IntTypes.int_t", "Lib.IntTypes.U8", "Lib.IntTypes.SEC", "Lib.NTuple.tup8" ]	[]	false	true	false	false	false	let load_blocks8 #a #m ib ws =	let h0 = ST.get () in let b0, (b1, (b2, (b3, (b4, (b5, (b6, b7)))))) = NTup.tup8 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b4 0ul; set_wsi ws 5ul b5 0ul; set_wsi ws 6ul b6 0ul; let h1 = ST.get () in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b7 0ul; set_wsi ws 8ul b0 1ul; set_wsi ws 9ul b1 1ul; set_wsi ws 10ul b2 1ul; set_wsi ws 11ul b3 1ul; set_wsi ws 12ul b4 1ul; set_wsi ws 13ul b5 1ul; set_wsi ws 14ul b6 1ul; set_wsi ws 15ul b7 1ul; let h1 = ST.get () in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec8 (as_seq_multi h0 ib)); load_blocks_spec8_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec8 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); ()	false
Vale.Stdcalls.X64.GCMdecryptOpt.fst	Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_decrypt_opt		val gcm256_decrypt_opt : Vale.Interop.Base.normal ( s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.Stdcalls.X64.GCMdecryptOpt.lowstar_gcm256_t s iv)	let gcm256_decrypt_opt //: normal ((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gcm256_t s) = as_normal_t #((s:Ghost.erased (Seq.seq nat32)) -> (iv:Ghost.erased supported_iv_LE) -> lowstar_gcm256_t s iv) (fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) -> lowstar_gcm256 s iv)	{ "file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCMdecryptOpt.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 209, "end_line": 404, "start_col": 0, "start_line": 403 }	module Vale.Stdcalls.X64.GCMdecryptOpt open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open FStar.Mul module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s module GC = Vale.AES.X64.GCMdecryptOpt open Vale.AES.AES_s open Vale.AES.GCM_s let uint64 = UInt64.t (* A little utility to trigger normalization in types ) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let b128 = buf_t TUInt8 TUInt128 [@__reduce__] noextract let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq [@__reduce__] noextract let t128_mod_pub = TD_Buffer TUInt8 TUInt128 ({modified=true; strict_disjointness=false; taint=MS.Public}) [@__reduce__] noextract let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) [@__reduce__] noextract let tuint64 = TD_Base TUInt64 [@__reduce__] noextract let (dom: list td{List.length dom <= 20}) = let y = [t128_no_mod; tuint64; tuint64; t128_no_mod; t128_mod_pub; t128_no_mod; t128_no_mod; t128_no_mod; t128_mod; tuint64; t128_no_mod; t128_mod; tuint64; t128_mod; tuint64; t128_mod; t128_no_mod] in assert_norm (List.length y = 17); y ( Need to rearrange the order of arguments ) [@__reduce__] noextract let gcm128_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm128_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100" [@__reduce__] noextract let gcm128_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f ( Prove that gcm128_lemma' has the required type ) noextract let gcm128_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm128_pre s iv) (gcm128_post s iv)) (gcm128_lemma' s iv) noextract let code_gcm128 = GC.va_code_Gcm_blocks_decrypt_stdcall IA.win AES_128 ( Here's the type expected for the gcm wrapper ) [@__reduce__] noextract let lowstar_gcm128_t (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.as_lowstar_sig_t_weak_stdcall code_gcm128 dom [] _ _ (W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win)) ( And here's the gcm wrapper itself ) noextract let lowstar_gcm128 (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) : lowstar_gcm128_t s iv = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.wrap_weak_stdcall code_gcm128 dom (W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win)) ( Need to rearrange the order of arguments ) [@__reduce__] noextract let gcm256_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm256_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100" [@__reduce__] noextract let gcm256_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_256 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f ( Prove that gcm256_lemma' has the required type ) noextract let gcm256_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm256_pre s iv) (gcm256_post s iv)) (gcm256_lemma' s iv) noextract let code_gcm256 = GC.va_code_Gcm_blocks_decrypt_stdcall IA.win AES_256 ( Here's the type expected for the gcm wrapper ) [@__reduce__] noextract let lowstar_gcm256_t (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.as_lowstar_sig_t_weak_stdcall code_gcm256 dom [] _ _ (W.mk_prediction code_gcm256 dom [] ((gcm256_lemma s iv) code_gcm256 IA.win)) ( And here's the gcm wrapper itself *) noextract let lowstar_gcm256 (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) : lowstar_gcm256_t s iv = assert_norm (List.length dom + List.length ([]<:list arg) <= 20); IX64.wrap_weak_stdcall code_gcm256 dom (W.mk_prediction code_gcm256 dom [] ((gcm256_lemma s iv) code_gcm256 IA.win)) [@ (CCConv "stdcall") ] let gcm128_decrypt_opt //: normal ((s:Ghost.erased (Seq.seq nat32)) -> lowstar_gcm128_t s) = as_normal_t #((s:Ghost.erased (Seq.seq nat32)) -> (iv:Ghost.erased supported_iv_LE) -> lowstar_gcm128_t s iv) (fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) -> lowstar_gcm128 s iv)	{ "checked_file": "/", "dependencies": [ "Vale.X64.State.fsti.checked", "Vale.X64.MemoryAdapters.fsti.checked", "Vale.X64.Memory.fsti.checked", "Vale.X64.Machine_s.fst.checked", "Vale.X64.Decls.fsti.checked", "Vale.Interop.X64.fsti.checked", "Vale.Interop.Base.fst.checked", "Vale.Interop.Assumptions.fst.checked", "Vale.Def.Types_s.fst.checked", "Vale.AsLowStar.Wrapper.fsti.checked", "Vale.AsLowStar.ValeSig.fst.checked", "Vale.AsLowStar.MemoryHelpers.fsti.checked", "Vale.AsLowStar.LowStarSig.fst.checked", "Vale.AES.X64.GCMdecryptOpt.fsti.checked", "Vale.AES.GCM_s.fst.checked", "Vale.AES.AES_s.fst.checked", "prims.fst.checked", "LowStar.BufferView.Up.fsti.checked", "LowStar.BufferView.Down.fsti.checked", "LowStar.Buffer.fst.checked", "FStar.UInt64.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.List.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": false, "source_file": "Vale.Stdcalls.X64.GCMdecryptOpt.fst" }	[ { "abbrev": false, "full_module": "Vale.AES.GCM_s", "short_module": null }, { "abbrev": false, "full_module": "Vale.AES.AES_s", "short_module": null }, { "abbrev": true, "full_module": "Vale.AES.X64.GCMdecryptOpt", "short_module": "GC" }, { "abbrev": true, "full_module": "Vale.X64.Machine_s", "short_module": "MS" }, { "abbrev": true, "full_module": "Vale.X64.State", "short_module": "VS" }, { "abbrev": false, "full_module": "Vale.X64.MemoryAdapters", "short_module": null }, { "abbrev": true, "full_module": "Vale.AsLowStar.Wrapper", "short_module": "W" }, { "abbrev": true, "full_module": "Vale.Interop.Assumptions", "short_module": "IA" }, { "abbrev": true, "full_module": "Vale.X64.Decls", "short_module": "V" }, { "abbrev": true, "full_module": "Vale.X64.Memory", "short_module": "ME" }, { "abbrev": true, "full_module": "Vale.AsLowStar.LowStarSig", "short_module": "LSig" }, { "abbrev": true, "full_module": "Vale.AsLowStar.ValeSig", "short_module": "VSig" }, { "abbrev": true, "full_module": "Vale.Interop.X64", "short_module": "IX64" }, { "abbrev": false, "full_module": "Vale.Interop.Base", "short_module": null }, { "abbrev": false, "full_module": "Vale.Def.Types_s", "short_module": null }, { "abbrev": true, "full_module": "LowStar.BufferView.Up", "short_module": "UV" }, { "abbrev": true, "full_module": "LowStar.BufferView.Down", "short_module": "DV" }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "FStar.HyperStack.ST", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 0, "max_fuel": 1, "max_ifuel": 1, "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": true, "smtencoding_l_arith_repr": "native", "smtencoding_nl_arith_repr": "wrapped", "smtencoding_valid_elim": false, "smtencoding_valid_intro": true, "tcnorm": true, "trivial_pre_for_unannotated_effectful_fns": false, "z3cliopt": [ "smt.arith.nl=false", "smt.QI.EAGER_THRESHOLD=100", "smt.CASE_SPLIT=3" ], "z3refresh": false, "z3rlimit": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	Vale.Interop.Base.normal ( s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> Vale.Stdcalls.X64.GCMdecryptOpt.lowstar_gcm256_t s iv)	Prims.Tot	[ "total" ]	[]	[ "Vale.Stdcalls.X64.GCMdecryptOpt.as_normal_t", "FStar.Ghost.erased", "FStar.Seq.Base.seq", "Vale.Def.Types_s.nat32", "Vale.AES.GCM_s.supported_iv_LE", "Vale.Stdcalls.X64.GCMdecryptOpt.lowstar_gcm256_t", "Vale.Stdcalls.X64.GCMdecryptOpt.lowstar_gcm256" ]	[]	false	false	false	false	false	let gcm256_decrypt_opt =	as_normal_t #(s: Ghost.erased (Seq.seq nat32) -> iv: Ghost.erased supported_iv_LE -> lowstar_gcm256_t s iv) (fun (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) -> lowstar_gcm256 s iv)	false
Hacl.Impl.SHA2.Core.fst	Hacl.Impl.SHA2.Core.load_blocks1	val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	let load_blocks1 #a #m ib ws = let h0 = ST.get() in let b = ib.(\|0\|) in set_wsi ws 0ul b 0ul; set_wsi ws 1ul b 1ul; set_wsi ws 2ul b 2ul; set_wsi ws 3ul b 3ul; set_wsi ws 4ul b 4ul; set_wsi ws 5ul b 5ul; set_wsi ws 6ul b 6ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b 7ul; set_wsi ws 8ul b 8ul; set_wsi ws 9ul b 9ul; set_wsi ws 10ul b 10ul; set_wsi ws 11ul b 11ul; set_wsi ws 12ul b 12ul; set_wsi ws 13ul b 13ul; set_wsi ws 14ul b 14ul; set_wsi ws 15ul b 15ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib)); load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib))	{ "file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 67, "end_line": 125, "start_col": 0, "start_line": 99 }	module Hacl.Impl.SHA2.Core open FStar.Mul open FStar.HyperStack open FStar.HyperStack.All open Lib.IntTypes open Lib.NTuple open Lib.Buffer open Lib.IntVector open Lib.MultiBuffer open Spec.Hash.Definitions //open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq open Hacl.Spec.SHA2.Vec module ST = FStar.HyperStack.ST module NTup = Lib.NTuple module SpecVec = Hacl.Spec.SHA2.Vec module VecTranspose = Lib.IntVector.Transpose module LSeq = Lib.Sequence module HD = Hacl.Hash.Definitions (* Force ordering in dependency analysis so that monomorphizations are inserted into the Types module first. ) let _ = Hacl.Impl.SHA2.Types.uint8_8p #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" unfold let state_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 8ul unfold let block_t (a:sha2_alg) = lbuffer uint8 (HD.block_len a) inline_for_extraction noextract let ws_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 16ul inline_for_extraction noextract val set_wsi: #a:sha2_alg -> #m:m_spec -> ws:ws_t a m -> i:size_t{v i < 16} -> b:lbuffer uint8 (HD.block_len a) -> bi:size_t{v bi < 16 / (lanes a m)} -> Stack unit (requires fun h -> live h b /\ live h ws /\ disjoint b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == LSeq.upd (as_seq h0 ws) (v i) (SpecVec.load_elementi #a #m (as_seq h0 b) (v bi))) let set_wsi #a #m ws i b bi = [@inline_let] let l = lanes a m in ws.(i) <- vec_load_be (word_t a) l (sub b (bi ! size l ! HD.word_len a) (size l ! HD.word_len a)) noextract let load_blocks_spec1 (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : ws_spec a m = let b = b.(\|0\|) in let ws0 = SpecVec.load_elementi b 0 in let ws1 = SpecVec.load_elementi b 1 in let ws2 = SpecVec.load_elementi b 2 in let ws3 = SpecVec.load_elementi b 3 in let ws4 = SpecVec.load_elementi b 4 in let ws5 = SpecVec.load_elementi b 5 in let ws6 = SpecVec.load_elementi b 6 in let ws7 = SpecVec.load_elementi b 7 in let ws8 = SpecVec.load_elementi b 8 in let ws9 = SpecVec.load_elementi b 9 in let ws10 = SpecVec.load_elementi b 10 in let ws11 = SpecVec.load_elementi b 11 in let ws12 = SpecVec.load_elementi b 12 in let ws13 = SpecVec.load_elementi b 13 in let ws14 = SpecVec.load_elementi b 14 in let ws15 = SpecVec.load_elementi b 15 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec1 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec1 b) #push-options "--z3rlimit 100" inline_for_extraction noextract val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))	{ "checked_file": "/", "dependencies": [ "Spec.Hash.Definitions.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.NTuple.fsti.checked", "Lib.MultiBuffer.fst.checked", "Lib.IntVector.Transpose.fsti.checked", "Lib.IntVector.Serialize.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Lib.Buffer.fsti.checked", "Hacl.Spec.SHA2.Vec.fst.checked", "Hacl.Impl.SHA2.Types.fst.checked", "Hacl.Hash.Definitions.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.All.fst.checked", "FStar.HyperStack.fst.checked" ], "interface_file": false, "source_file": "Hacl.Impl.SHA2.Core.fst" }	[ { "abbrev": true, "full_module": "Hacl.Hash.Definitions", "short_module": "HD" }, { "abbrev": true, "full_module": "Lib.Sequence", "short_module": "LSeq" }, { "abbrev": true, "full_module": "Lib.IntVector.Transpose", "short_module": "VecTranspose" }, { "abbrev": true, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": "SpecVec" }, { "abbrev": true, "full_module": "Lib.NTuple", "short_module": "NTup" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "ST" }, { "abbrev": false, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": null }, { "abbrev": false, "full_module": "Spec.Hash.Definitions", "short_module": null }, { "abbrev": false, "full_module": "Lib.MultiBuffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.Buffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.NTuple", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack.All", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "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 } ]	{ "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": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	b: Lib.MultiBuffer.multibuf (Hacl.Spec.SHA2.Vec.lanes a m) (Hacl.Hash.Definitions.block_len a) -> ws: Hacl.Impl.SHA2.Core.ws_t a m -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Spec.Hash.Definitions.sha2_alg", "Hacl.Spec.SHA2.Vec.m_spec", "Prims.eq2", "Prims.int", "Hacl.Spec.SHA2.Vec.lanes", "Lib.MultiBuffer.multibuf", "Hacl.Hash.Definitions.block_len", "Hacl.Impl.SHA2.Core.ws_t", "Prims._assert", "Lib.Sequence.lseq", "Hacl.Spec.SHA2.Vec.element_t", "Lib.Buffer.as_seq", "Lib.Buffer.MUT", "FStar.UInt32.__uint_to_t", "Hacl.Spec.SHA2.Vec.load_blocks", "Lib.MultiBuffer.as_seq_multi", "Prims.unit", "Lib.IntTypes.v", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "Hacl.Impl.SHA2.Core.load_blocks_spec1", "Hacl.Impl.SHA2.Core.load_blocks_spec1_lemma", "Lib.Sequence.eq_intro", "Lib.Buffer.modifies", "Lib.Buffer.loc", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Hacl.Impl.SHA2.Core.set_wsi", "Lib.Buffer.lbuffer_t", "Lib.IntTypes.int_t", "Lib.IntTypes.U8", "Lib.IntTypes.SEC", "Lib.MultiBuffer.op_Lens_Access", "Lib.Buffer.lbuffer", "Lib.IntTypes.uint8" ]	[]	false	true	false	false	false	let load_blocks1 #a #m ib ws =	let h0 = ST.get () in let b = ib.(\| 0 \|) in set_wsi ws 0ul b 0ul; set_wsi ws 1ul b 1ul; set_wsi ws 2ul b 2ul; set_wsi ws 3ul b 3ul; set_wsi ws 4ul b 4ul; set_wsi ws 5ul b 5ul; set_wsi ws 6ul b 6ul; let h1 = ST.get () in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b 7ul; set_wsi ws 8ul b 8ul; set_wsi ws 9ul b 9ul; set_wsi ws 10ul b 10ul; set_wsi ws 11ul b 11ul; set_wsi ws 12ul b 12ul; set_wsi ws 13ul b 13ul; set_wsi ws 14ul b 14ul; set_wsi ws 15ul b 15ul; let h1 = ST.get () in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib)); load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib))	false
Test.Vectors.Chacha20Poly1305.fst	Test.Vectors.Chacha20Poly1305.input10	val input10:(b: B.buffer UInt8.t {B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10})	val input10:(b: B.buffer UInt8.t {B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10})	let input10: (b: B.buffer UInt8.t { B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10 }) = B.recall aad10;[@inline_let] let l = [ 0x7auy; 0x57uy; 0xf2uy; 0xc7uy; 0x06uy; 0x3fuy; 0x50uy; 0x7buy; 0x36uy; 0x1auy; 0x66uy; 0x5cuy; 0xb9uy; 0x0euy; 0x5euy; 0x3buy; 0x45uy; 0x60uy; 0xbeuy; 0x9auy; 0x31uy; 0x9fuy; 0xffuy; 0x5duy; 0x66uy; 0x34uy; 0xb4uy; 0xdcuy; 0xfbuy; 0x9duy; 0x8euy; 0xeeuy; 0x6auy; 0x33uy; 0xa4uy; 0x07uy; 0x3cuy; 0xf9uy; 0x4cuy; 0x30uy; 0xa1uy; 0x24uy; 0x52uy; 0xf9uy; 0x50uy; 0x46uy; 0x88uy; 0x20uy; 0x02uy; 0x32uy; 0x3auy; 0x0euy; 0x99uy; 0x63uy; 0xafuy; 0x1fuy; 0x15uy; 0x28uy; 0x2auy; 0x05uy; 0xffuy; 0x57uy; 0x59uy; 0x5euy; 0x18uy; 0xa1uy; 0x1fuy; 0xd0uy; 0x92uy; 0x5cuy; 0x88uy; 0x66uy; 0x1buy; 0x00uy; 0x64uy; 0xa5uy; 0x93uy; 0x8duy; 0x06uy; 0x46uy; 0xb0uy; 0x64uy; 0x8buy; 0x8buy; 0xefuy; 0x99uy; 0x05uy; 0x35uy; 0x85uy; 0xb3uy; 0xf3uy; 0x33uy; 0xbbuy; 0xecuy; 0x66uy; 0xb6uy; 0x3duy; 0x57uy; 0x42uy; 0xe3uy; 0xb4uy; 0xc6uy; 0xaauy; 0xb0uy; 0x41uy; 0x2auy; 0xb9uy; 0x59uy; 0xa9uy; 0xf6uy; 0x3euy; 0x15uy; 0x26uy; 0x12uy; 0x03uy; 0x21uy; 0x4cuy; 0x74uy; 0x43uy; 0x13uy; 0x2auy; 0x03uy; 0x27uy; 0x09uy; 0xb4uy; 0xfbuy; 0xe7uy; 0xb7uy; 0x40uy; 0xffuy; 0x5euy; 0xceuy; 0x48uy; 0x9auy; 0x60uy; 0xe3uy; 0x8buy; 0x80uy; 0x8cuy; 0x38uy; 0x2duy; 0xcbuy; 0x93uy; 0x37uy; 0x74uy; 0x05uy; 0x52uy; 0x6fuy; 0x73uy; 0x3euy; 0xc3uy; 0xbcuy; 0xcauy; 0x72uy; 0x0auy; 0xebuy; 0xf1uy; 0x3buy; 0xa0uy; 0x95uy; 0xdcuy; 0x8auy; 0xc4uy; 0xa9uy; 0xdcuy; 0xcauy; 0x44uy; 0xd8uy; 0x08uy; 0x63uy; 0x6auy; 0x36uy; 0xd3uy; 0x3cuy; 0xb8uy; 0xacuy; 0x46uy; 0x7duy; 0xfduy; 0xaauy; 0xebuy; 0x3euy; 0x0fuy; 0x45uy; 0x8fuy; 0x49uy; 0xdauy; 0x2buy; 0xf2uy; 0x12uy; 0xbduy; 0xafuy; 0x67uy; 0x8auy; 0x63uy; 0x48uy; 0x4buy; 0x55uy; 0x5fuy; 0x6duy; 0x8cuy; 0xb9uy; 0x76uy; 0x34uy; 0x84uy; 0xaeuy; 0xc2uy; 0xfcuy; 0x52uy; 0x64uy; 0x82uy; 0xf7uy; 0xb0uy; 0x06uy; 0xf0uy; 0x45uy; 0x73uy; 0x12uy; 0x50uy; 0x30uy; 0x72uy; 0xeauy; 0x78uy; 0x9auy; 0xa8uy; 0xafuy; 0xb5uy; 0xe3uy; 0xbbuy; 0x77uy; 0x52uy; 0xecuy; 0x59uy; 0x84uy; 0xbfuy; 0x6buy; 0x8fuy; 0xceuy; 0x86uy; 0x5euy; 0x1fuy; 0x23uy; 0xe9uy; 0xfbuy; 0x08uy; 0x86uy; 0xf7uy; 0x10uy; 0xb9uy; 0xf2uy; 0x44uy; 0x96uy; 0x44uy; 0x63uy; 0xa9uy; 0xa8uy; 0x78uy; 0x00uy; 0x23uy; 0xd6uy; 0xc7uy; 0xe7uy; 0x6euy; 0x66uy; 0x4fuy; 0xccuy; 0xeeuy; 0x15uy; 0xb3uy; 0xbduy; 0x1duy; 0xa0uy; 0xe5uy; 0x9cuy; 0x1buy; 0x24uy; 0x2cuy; 0x4duy; 0x3cuy; 0x62uy; 0x35uy; 0x9cuy; 0x88uy; 0x59uy; 0x09uy; 0xdduy; 0x82uy; 0x1buy; 0xcfuy; 0x0auy; 0x83uy; 0x6buy; 0x3fuy; 0xaeuy; 0x03uy; 0xc4uy; 0xb4uy; 0xdduy; 0x7euy; 0x5buy; 0x28uy; 0x76uy; 0x25uy; 0x96uy; 0xd9uy; 0xc9uy; 0x9duy; 0x5fuy; 0x86uy; 0xfauy; 0xf6uy; 0xd7uy; 0xd2uy; 0xe6uy; 0x76uy; 0x1duy; 0x0fuy; 0xa1uy; 0xdcuy; 0x74uy; 0x05uy; 0x1buy; 0x1duy; 0xe0uy; 0xcduy; 0x16uy; 0xb0uy; 0xa8uy; 0x8auy; 0x34uy; 0x7buy; 0x15uy; 0x11uy; 0x77uy; 0xe5uy; 0x7buy; 0x7euy; 0x20uy; 0xf7uy; 0xdauy; 0x38uy; 0xdauy; 0xceuy; 0x70uy; 0xe9uy; 0xf5uy; 0x6cuy; 0xd9uy; 0xbeuy; 0x0cuy; 0x4cuy; 0x95uy; 0x4cuy; 0xc2uy; 0x9buy; 0x34uy; 0x55uy; 0x55uy; 0xe1uy; 0xf3uy; 0x46uy; 0x8euy; 0x48uy; 0x74uy; 0x14uy; 0x4fuy; 0x9duy; 0xc9uy; 0xf5uy; 0xe8uy; 0x1auy; 0xf0uy; 0x11uy; 0x4auy; 0xc1uy; 0x8duy; 0xe0uy; 0x93uy; 0xa0uy; 0xbeuy; 0x09uy; 0x1cuy; 0x2buy; 0x4euy; 0x0fuy; 0xb2uy; 0x87uy; 0x8buy; 0x84uy; 0xfeuy; 0x92uy; 0x32uy; 0x14uy; 0xd7uy; 0x93uy; 0xdfuy; 0xe7uy; 0x44uy; 0xbcuy; 0xc5uy; 0xaeuy; 0x53uy; 0x69uy; 0xd8uy; 0xb3uy; 0x79uy; 0x37uy; 0x80uy; 0xe3uy; 0x17uy; 0x5cuy; 0xecuy; 0x53uy; 0x00uy; 0x9auy; 0xe3uy; 0x8euy; 0xdcuy; 0x38uy; 0xb8uy; 0x66uy; 0xf0uy; 0xd3uy; 0xaduy; 0x1duy; 0x02uy; 0x96uy; 0x86uy; 0x3euy; 0x9duy; 0x3buy; 0x5duy; 0xa5uy; 0x7fuy; 0x21uy; 0x10uy; 0xf1uy; 0x1fuy; 0x13uy; 0x20uy; 0xf9uy; 0x57uy; 0x87uy; 0x20uy; 0xf5uy; 0x5fuy; 0xf1uy; 0x17uy; 0x48uy; 0x0auy; 0x51uy; 0x5auy; 0xcduy; 0x19uy; 0x03uy; 0xa6uy; 0x5auy; 0xd1uy; 0x12uy; 0x97uy; 0xe9uy; 0x48uy; 0xe2uy; 0x1duy; 0x83uy; 0x75uy; 0x50uy; 0xd9uy; 0x75uy; 0x7duy; 0x6auy; 0x82uy; 0xa1uy; 0xf9uy; 0x4euy; 0x54uy; 0x87uy; 0x89uy; 0xc9uy; 0x0cuy; 0xb7uy; 0x5buy; 0x6auy; 0x91uy; 0xc1uy; 0x9cuy; 0xb2uy; 0xa9uy; 0xdcuy; 0x9auy; 0xa4uy; 0x49uy; 0x0auy; 0x6duy; 0x0duy; 0xbbuy; 0xdeuy; 0x86uy; 0x44uy; 0xdduy; 0x5duy; 0x89uy; 0x2buy; 0x96uy; 0x0fuy; 0x23uy; 0x95uy; 0xaduy; 0xccuy; 0xa2uy; 0xb3uy; 0xb9uy; 0x7euy; 0x74uy; 0x38uy; 0xbauy; 0x9fuy; 0x73uy; 0xaeuy; 0x5fuy; 0xf8uy; 0x68uy; 0xa2uy; 0xe0uy; 0xa9uy; 0xceuy; 0xbduy; 0x40uy; 0xd4uy; 0x4cuy; 0x6buy; 0xd2uy; 0x56uy; 0x62uy; 0xb0uy; 0xccuy; 0x63uy; 0x7euy; 0x5buy; 0xd3uy; 0xaeuy; 0xd1uy; 0x75uy; 0xceuy; 0xbbuy; 0xb4uy; 0x5buy; 0xa8uy; 0xf8uy; 0xb4uy; 0xacuy; 0x71uy; 0x75uy; 0xaauy; 0xc9uy; 0x9fuy; 0xbbuy; 0x6cuy; 0xaduy; 0x0fuy; 0x55uy; 0x5duy; 0xe8uy; 0x85uy; 0x7duy; 0xf9uy; 0x21uy; 0x35uy; 0xeauy; 0x92uy; 0x85uy; 0x2buy; 0x00uy; 0xecuy; 0x84uy; 0x90uy; 0x0auy; 0x63uy; 0x96uy; 0xe4uy; 0x6buy; 0xa9uy; 0x77uy; 0xb8uy; 0x91uy; 0xf8uy; 0x46uy; 0x15uy; 0x72uy; 0x63uy; 0x70uy; 0x01uy; 0x40uy; 0xa3uy; 0xa5uy; 0x76uy; 0x62uy; 0x2buy; 0xbfuy; 0xf1uy; 0xe5uy; 0x8duy; 0x9fuy; 0xa3uy; 0xfauy; 0x9buy; 0x03uy; 0xbeuy; 0xfeuy; 0x65uy; 0x6fuy; 0xa2uy; 0x29uy; 0x0duy; 0x54uy; 0xb4uy; 0x71uy; 0xceuy; 0xa9uy; 0xd6uy; 0x3duy; 0x88uy; 0xf9uy; 0xafuy; 0x6buy; 0xa8uy; 0x9euy; 0xf4uy; 0x16uy; 0x96uy; 0x36uy; 0xb9uy; 0x00uy; 0xdcuy; 0x10uy; 0xabuy; 0xb5uy; 0x08uy; 0x31uy; 0x1fuy; 0x00uy; 0xb1uy; 0x3cuy; 0xd9uy; 0x38uy; 0x3euy; 0xc6uy; 0x04uy; 0xa7uy; 0x4euy; 0xe8uy; 0xaeuy; 0xeduy; 0x98uy; 0xc2uy; 0xf7uy; 0xb9uy; 0x00uy; 0x5fuy; 0x8cuy; 0x60uy; 0xd1uy; 0xe5uy; 0x15uy; 0xf7uy; 0xaeuy; 0x1euy; 0x84uy; 0x88uy; 0xd1uy; 0xf6uy; 0xbcuy; 0x3auy; 0x89uy; 0x35uy; 0x22uy; 0x83uy; 0x7cuy; 0xcauy; 0xf0uy; 0x33uy; 0x82uy; 0x4cuy; 0x79uy; 0x3cuy; 0xfduy; 0xb1uy; 0xaeuy; 0x52uy; 0x62uy; 0x55uy; 0xd2uy; 0x41uy; 0x60uy; 0xc6uy; 0xbbuy; 0xfauy; 0x0euy; 0x59uy; 0xd6uy; 0xa8uy; 0xfeuy; 0x5duy; 0xeduy; 0x47uy; 0x3duy; 0xe0uy; 0xeauy; 0x1fuy; 0x6euy; 0x43uy; 0x51uy; 0xecuy; 0x10uy; 0x52uy; 0x56uy; 0x77uy; 0x42uy; 0x6buy; 0x52uy; 0x87uy; 0xd8uy; 0xecuy; 0xe0uy; 0xaauy; 0x76uy; 0xa5uy; 0x84uy; 0x2auy; 0x22uy; 0x24uy; 0xfduy; 0x92uy; 0x40uy; 0x88uy; 0xd5uy; 0x85uy; 0x1cuy; 0x1fuy; 0x6buy; 0x47uy; 0xa0uy; 0xc4uy; 0xe4uy; 0xefuy; 0xf4uy; 0xeauy; 0xd7uy; 0x59uy; 0xacuy; 0x2auy; 0x9euy; 0x8cuy; 0xfauy; 0x1fuy; 0x42uy; 0x08uy; 0xfeuy; 0x4fuy; 0x74uy; 0xa0uy; 0x26uy; 0xf5uy; 0xb3uy; 0x84uy; 0xf6uy; 0x58uy; 0x5fuy; 0x26uy; 0x66uy; 0x3euy; 0xd7uy; 0xe4uy; 0x22uy; 0x91uy; 0x13uy; 0xc8uy; 0xacuy; 0x25uy; 0x96uy; 0x23uy; 0xd8uy; 0x09uy; 0xeauy; 0x45uy; 0x75uy; 0x23uy; 0xb8uy; 0x5fuy; 0xc2uy; 0x90uy; 0x8buy; 0x09uy; 0xc4uy; 0xfcuy; 0x47uy; 0x6cuy; 0x6duy; 0x0auy; 0xefuy; 0x69uy; 0xa4uy; 0x38uy; 0x19uy; 0xcfuy; 0x7duy; 0xf9uy; 0x09uy; 0x73uy; 0x9buy; 0x60uy; 0x5auy; 0xf7uy; 0x37uy; 0xb5uy; 0xfeuy; 0x9fuy; 0xe3uy; 0x2buy; 0x4cuy; 0x0duy; 0x6euy; 0x19uy; 0xf1uy; 0xd6uy; 0xc0uy; 0x70uy; 0xf3uy; 0x9duy; 0x22uy; 0x3cuy; 0xf9uy; 0x49uy; 0xceuy; 0x30uy; 0x8euy; 0x44uy; 0xb5uy; 0x76uy; 0x15uy; 0x8fuy; 0x52uy; 0xfduy; 0xa5uy; 0x04uy; 0xb8uy; 0x55uy; 0x6auy; 0x36uy; 0x59uy; 0x7cuy; 0xc4uy; 0x48uy; 0xb8uy; 0xd7uy; 0xabuy; 0x05uy; 0x66uy; 0xe9uy; 0x5euy; 0x21uy; 0x6fuy; 0x6buy; 0x36uy; 0x29uy; 0xbbuy; 0xe9uy; 0xe3uy; 0xa2uy; 0x9auy; 0xa8uy; 0xcduy; 0x55uy; 0x25uy; 0x11uy; 0xbauy; 0x5auy; 0x58uy; 0xa0uy; 0xdeuy; 0xaeuy; 0x19uy; 0x2auy; 0x48uy; 0x5auy; 0xffuy; 0x36uy; 0xcduy; 0x6duy; 0x16uy; 0x7auy; 0x73uy; 0x38uy; 0x46uy; 0xe5uy; 0x47uy; 0x59uy; 0xc8uy; 0xa2uy; 0xf6uy; 0xe2uy; 0x6cuy; 0x83uy; 0xc5uy; 0x36uy; 0x2cuy; 0x83uy; 0x7duy; 0xb4uy; 0x01uy; 0x05uy; 0x69uy; 0xe7uy; 0xafuy; 0x5cuy; 0xc4uy; 0x64uy; 0x82uy; 0x12uy; 0x21uy; 0xefuy; 0xf7uy; 0xd1uy; 0x7duy; 0xb8uy; 0x8duy; 0x8cuy; 0x98uy; 0x7cuy; 0x5fuy; 0x7duy; 0x92uy; 0x88uy; 0xb9uy; 0x94uy; 0x07uy; 0x9cuy; 0xd8uy; 0xe9uy; 0x9cuy; 0x17uy; 0x38uy; 0xe3uy; 0x57uy; 0x6cuy; 0xe0uy; 0xdcuy; 0xa5uy; 0x92uy; 0x42uy; 0xb3uy; 0xbduy; 0x50uy; 0xa2uy; 0x7euy; 0xb5uy; 0xb1uy; 0x52uy; 0x72uy; 0x03uy; 0x97uy; 0xd8uy; 0xaauy; 0x9auy; 0x1euy; 0x75uy; 0x41uy; 0x11uy; 0xa3uy; 0x4fuy; 0xccuy; 0xd4uy; 0xe3uy; 0x73uy; 0xaduy; 0x96uy; 0xdcuy; 0x47uy; 0x41uy; 0x9fuy; 0xb0uy; 0xbeuy; 0x79uy; 0x91uy; 0xf5uy; 0xb6uy; 0x18uy; 0xfeuy; 0xc2uy; 0x83uy; 0x18uy; 0x7duy; 0x73uy; 0xd9uy; 0x4fuy; 0x83uy; 0x84uy; 0x03uy; 0xb3uy; 0xf0uy; 0x77uy; 0x66uy; 0x3duy; 0x83uy; 0x63uy; 0x2euy; 0x2cuy; 0xf9uy; 0xdduy; 0xa6uy; 0x1fuy; 0x89uy; 0x82uy; 0xb8uy; 0x23uy; 0x42uy; 0xebuy; 0xe2uy; 0xcauy; 0x70uy; 0x82uy; 0x61uy; 0x41uy; 0x0auy; 0x6duy; 0x5fuy; 0x75uy; 0xc5uy; 0xe2uy; 0xc4uy; 0x91uy; 0x18uy; 0x44uy; 0x22uy; 0xfauy; 0x34uy; 0x10uy; 0xf5uy; 0x20uy; 0xdcuy; 0xb7uy; 0xdduy; 0x2auy; 0x20uy; 0x77uy; 0xf5uy; 0xf9uy; 0xceuy; 0xdbuy; 0xa0uy; 0x0auy; 0x52uy; 0x2auy; 0x4euy; 0xdduy; 0xccuy; 0x97uy; 0xdfuy; 0x05uy; 0xe4uy; 0x5euy; 0xb7uy; 0xaauy; 0xf0uy; 0xe2uy; 0x80uy; 0xffuy; 0xbauy; 0x1auy; 0x0fuy; 0xacuy; 0xdfuy; 0x02uy; 0x32uy; 0xe6uy; 0xf7uy; 0xc7uy; 0x17uy; 0x13uy; 0xb7uy; 0xfcuy; 0x98uy; 0x48uy; 0x8cuy; 0x0duy; 0x82uy; 0xc9uy; 0x80uy; 0x7auy; 0xe2uy; 0x0auy; 0xc5uy; 0xb4uy; 0xdeuy; 0x7cuy; 0x3cuy; 0x79uy; 0x81uy; 0x0euy; 0x28uy; 0x65uy; 0x79uy; 0x67uy; 0x82uy; 0x69uy; 0x44uy; 0x66uy; 0x09uy; 0xf7uy; 0x16uy; 0x1auy; 0xf9uy; 0x7duy; 0x80uy; 0xa1uy; 0x79uy; 0x14uy; 0xa9uy; 0xc8uy; 0x20uy; 0xfbuy; 0xa2uy; 0x46uy; 0xbeuy; 0x08uy; 0x35uy; 0x17uy; 0x58uy; 0xc1uy; 0x1auy; 0xdauy; 0x2auy; 0x6buy; 0x2euy; 0x1euy; 0xe6uy; 0x27uy; 0x55uy; 0x7buy; 0x19uy; 0xe2uy; 0xfbuy; 0x64uy; 0xfcuy; 0x5euy; 0x15uy; 0x54uy; 0x3cuy; 0xe7uy; 0xc2uy; 0x11uy; 0x50uy; 0x30uy; 0xb8uy; 0x72uy; 0x03uy; 0x0buy; 0x1auy; 0x9fuy; 0x86uy; 0x27uy; 0x11uy; 0x5cuy; 0x06uy; 0x2buy; 0xbduy; 0x75uy; 0x1auy; 0x0auy; 0xdauy; 0x01uy; 0xfauy; 0x5cuy; 0x4auy; 0xc1uy; 0x80uy; 0x3auy; 0x6euy; 0x30uy; 0xc8uy; 0x2cuy; 0xebuy; 0x56uy; 0xecuy; 0x89uy; 0xfauy; 0x35uy; 0x7buy; 0xb2uy; 0xf0uy; 0x97uy; 0x08uy; 0x86uy; 0x53uy; 0xbeuy; 0xbduy; 0x40uy; 0x41uy; 0x38uy; 0x1cuy; 0xb4uy; 0x8buy; 0x79uy; 0x2euy; 0x18uy; 0x96uy; 0x94uy; 0xdeuy; 0xe8uy; 0xcauy; 0xe5uy; 0x9fuy; 0x92uy; 0x9fuy; 0x15uy; 0x5duy; 0x56uy; 0x60uy; 0x5cuy; 0x09uy; 0xf9uy; 0x16uy; 0xf4uy; 0x17uy; 0x0fuy; 0xf6uy; 0x4cuy; 0xdauy; 0xe6uy; 0x67uy; 0x89uy; 0x9fuy; 0xcauy; 0x6cuy; 0xe7uy; 0x9buy; 0x04uy; 0x62uy; 0x0euy; 0x26uy; 0xa6uy; 0x52uy; 0xbduy; 0x29uy; 0xffuy; 0xc7uy; 0xa4uy; 0x96uy; 0xe6uy; 0x6auy; 0x02uy; 0xa5uy; 0x2euy; 0x7buy; 0xfeuy; 0x97uy; 0x68uy; 0x3euy; 0x2euy; 0x5fuy; 0x3buy; 0x0fuy; 0x36uy; 0xd6uy; 0x98uy; 0x19uy; 0x59uy; 0x48uy; 0xd2uy; 0xc6uy; 0xe1uy; 0x55uy; 0x1auy; 0x6euy; 0xd6uy; 0xeduy; 0x2cuy; 0xbauy; 0xc3uy; 0x9euy; 0x64uy; 0xc9uy; 0x95uy; 0x86uy; 0x35uy; 0x5euy; 0x3euy; 0x88uy; 0x69uy; 0x99uy; 0x4buy; 0xeeuy; 0xbeuy; 0x9auy; 0x99uy; 0xb5uy; 0x6euy; 0x58uy; 0xaeuy; 0xdduy; 0x22uy; 0xdbuy; 0xdduy; 0x6buy; 0xfcuy; 0xafuy; 0x90uy; 0xa3uy; 0x3duy; 0xa4uy; 0xc1uy; 0x15uy; 0x92uy; 0x18uy; 0x8duy; 0xd2uy; 0x4buy; 0x7buy; 0x06uy; 0xd1uy; 0x37uy; 0xb5uy; 0xe2uy; 0x7cuy; 0x2cuy; 0xf0uy; 0x25uy; 0xe4uy; 0x94uy; 0x2auy; 0xbduy; 0xe3uy; 0x82uy; 0x70uy; 0x78uy; 0xa3uy; 0x82uy; 0x10uy; 0x5auy; 0x90uy; 0xd7uy; 0xa4uy; 0xfauy; 0xafuy; 0x1auy; 0x88uy; 0x59uy; 0xdcuy; 0x74uy; 0x12uy; 0xb4uy; 0x8euy; 0xd7uy; 0x19uy; 0x46uy; 0xf4uy; 0x84uy; 0x69uy; 0x9fuy; 0xbbuy; 0x70uy; 0xa8uy; 0x4cuy; 0x52uy; 0x81uy; 0xa9uy; 0xffuy; 0x76uy; 0x1cuy; 0xaeuy; 0xd8uy; 0x11uy; 0x3duy; 0x7fuy; 0x7duy; 0xc5uy; 0x12uy; 0x59uy; 0x28uy; 0x18uy; 0xc2uy; 0xa2uy; 0xb7uy; 0x1cuy; 0x88uy; 0xf8uy; 0xd6uy; 0x1buy; 0xa6uy; 0x7duy; 0x9euy; 0xdeuy; 0x29uy; 0xf8uy; 0xeduy; 0xffuy; 0xebuy; 0x92uy; 0x24uy; 0x4fuy; 0x05uy; 0xaauy; 0xd9uy; 0x49uy; 0xbauy; 0x87uy; 0x59uy; 0x51uy; 0xc9uy; 0x20uy; 0x5cuy; 0x9buy; 0x74uy; 0xcfuy; 0x03uy; 0xd9uy; 0x2duy; 0x34uy; 0xc7uy; 0x5buy; 0xa5uy; 0x40uy; 0xb2uy; 0x99uy; 0xf5uy; 0xcbuy; 0xb4uy; 0xf6uy; 0xb7uy; 0x72uy; 0x4auy; 0xd6uy; 0xbduy; 0xb0uy; 0xf3uy; 0x93uy; 0xe0uy; 0x1buy; 0xa8uy; 0x04uy; 0x1euy; 0x35uy; 0xd4uy; 0x80uy; 0x20uy; 0xf4uy; 0x9cuy; 0x31uy; 0x6buy; 0x45uy; 0xb9uy; 0x15uy; 0xb0uy; 0x5euy; 0xdduy; 0x0auy; 0x33uy; 0x9cuy; 0x83uy; 0xcduy; 0x58uy; 0x89uy; 0x50uy; 0x56uy; 0xbbuy; 0x81uy; 0x00uy; 0x91uy; 0x32uy; 0xf3uy; 0x1buy; 0x3euy; 0xcfuy; 0x45uy; 0xe1uy; 0xf9uy; 0xe1uy; 0x2cuy; 0x26uy; 0x78uy; 0x93uy; 0x9auy; 0x60uy; 0x46uy; 0xc9uy; 0xb5uy; 0x5euy; 0x6auy; 0x28uy; 0x92uy; 0x87uy; 0x3fuy; 0x63uy; 0x7buy; 0xdbuy; 0xf7uy; 0xd0uy; 0x13uy; 0x9duy; 0x32uy; 0x40uy; 0x5euy; 0xcfuy; 0xfbuy; 0x79uy; 0x68uy; 0x47uy; 0x4cuy; 0xfduy; 0x01uy; 0x17uy; 0xe6uy; 0x97uy; 0x93uy; 0x78uy; 0xbbuy; 0xa6uy; 0x27uy; 0xa3uy; 0xe8uy; 0x1auy; 0xe8uy; 0x94uy; 0x55uy; 0x7duy; 0x08uy; 0xe5uy; 0xdcuy; 0x66uy; 0xa3uy; 0x69uy; 0xc8uy; 0xcauy; 0xc5uy; 0xa1uy; 0x84uy; 0x55uy; 0xdeuy; 0x08uy; 0x91uy; 0x16uy; 0x3auy; 0x0cuy; 0x86uy; 0xabuy; 0x27uy; 0x2buy; 0x64uy; 0x34uy; 0x02uy; 0x6cuy; 0x76uy; 0x8buy; 0xc6uy; 0xafuy; 0xccuy; 0xe1uy; 0xd6uy; 0x8cuy; 0x2auy; 0x18uy; 0x3duy; 0xa6uy; 0x1buy; 0x37uy; 0x75uy; 0x45uy; 0x73uy; 0xc2uy; 0x75uy; 0xd7uy; 0x53uy; 0x78uy; 0x3auy; 0xd6uy; 0xe8uy; 0x29uy; 0xd2uy; 0x4auy; 0xa8uy; 0x1euy; 0x82uy; 0xf6uy; 0xb6uy; 0x81uy; 0xdeuy; 0x21uy; 0xeduy; 0x2buy; 0x56uy; 0xbbuy; 0xf2uy; 0xd0uy; 0x57uy; 0xc1uy; 0x7cuy; 0xd2uy; 0x6auy; 0xd2uy; 0x56uy; 0xf5uy; 0x13uy; 0x5fuy; 0x1cuy; 0x6auy; 0x0buy; 0x74uy; 0xfbuy; 0xe9uy; 0xfeuy; 0x9euy; 0xeauy; 0x95uy; 0xb2uy; 0x46uy; 0xabuy; 0x0auy; 0xfcuy; 0xfduy; 0xf3uy; 0xbbuy; 0x04uy; 0x2buy; 0x76uy; 0x1buy; 0xa4uy; 0x74uy; 0xb0uy; 0xc1uy; 0x78uy; 0xc3uy; 0x69uy; 0xe2uy; 0xb0uy; 0x01uy; 0xe1uy; 0xdeuy; 0x32uy; 0x4cuy; 0x8duy; 0x1auy; 0xb3uy; 0x38uy; 0x08uy; 0xd5uy; 0xfcuy; 0x1fuy; 0xdcuy; 0x0euy; 0x2cuy; 0x9cuy; 0xb1uy; 0xa1uy; 0x63uy; 0x17uy; 0x22uy; 0xf5uy; 0x6cuy; 0x93uy; 0x70uy; 0x74uy; 0x00uy; 0xf8uy; 0x39uy; 0x01uy; 0x94uy; 0xd1uy; 0x32uy; 0x23uy; 0x56uy; 0x5duy; 0xa6uy; 0x02uy; 0x76uy; 0x76uy; 0x93uy; 0xceuy; 0x2fuy; 0x19uy; 0xe9uy; 0x17uy; 0x52uy; 0xaeuy; 0x6euy; 0x2cuy; 0x6duy; 0x61uy; 0x7fuy; 0x3buy; 0xaauy; 0xe0uy; 0x52uy; 0x85uy; 0xc5uy; 0x65uy; 0xc1uy; 0xbbuy; 0x8euy; 0x5buy; 0x21uy; 0xd5uy; 0xc9uy; 0x78uy; 0x83uy; 0x07uy; 0x97uy; 0x4cuy; 0x62uy; 0x61uy; 0x41uy; 0xd4uy; 0xfcuy; 0xc9uy; 0x39uy; 0xe3uy; 0x9buy; 0xd0uy; 0xccuy; 0x75uy; 0xc4uy; 0x97uy; 0xe6uy; 0xdduy; 0x2auy; 0x5fuy; 0xa6uy; 0xe8uy; 0x59uy; 0x6cuy; 0x98uy; 0xb9uy; 0x02uy; 0xe2uy; 0xa2uy; 0xd6uy; 0x68uy; 0xeeuy; 0x3buy; 0x1duy; 0xe3uy; 0x4duy; 0x5buy; 0x30uy; 0xefuy; 0x03uy; 0xf2uy; 0xebuy; 0x18uy; 0x57uy; 0x36uy; 0xe8uy; 0xa1uy; 0xf4uy; 0x47uy; 0xfbuy; 0xcbuy; 0x8fuy; 0xcbuy; 0xc8uy; 0xf3uy; 0x4fuy; 0x74uy; 0x9duy; 0x9duy; 0xb1uy; 0x8duy; 0x14uy; 0x44uy; 0xd9uy; 0x19uy; 0xb4uy; 0x54uy; 0x4fuy; 0x75uy; 0x19uy; 0x09uy; 0xa0uy; 0x75uy; 0xbcuy; 0x3buy; 0x82uy; 0xc6uy; 0x3fuy; 0xb8uy; 0x83uy; 0x19uy; 0x6euy; 0xd6uy; 0x37uy; 0xfeuy; 0x6euy; 0x8auy; 0x4euy; 0xe0uy; 0x4auy; 0xabuy; 0x7buy; 0xc8uy; 0xb4uy; 0x1duy; 0xf4uy; 0xeduy; 0x27uy; 0x03uy; 0x65uy; 0xa2uy; 0xa1uy; 0xaeuy; 0x11uy; 0xe7uy; 0x98uy; 0x78uy; 0x48uy; 0x91uy; 0xd2uy; 0xd2uy; 0xd4uy; 0x23uy; 0x78uy; 0x50uy; 0xb1uy; 0x5buy; 0x85uy; 0x10uy; 0x8duy; 0xcauy; 0x5fuy; 0x0fuy; 0x71uy; 0xaeuy; 0x72uy; 0x9auy; 0xf6uy; 0x25uy; 0x19uy; 0x60uy; 0x06uy; 0xf7uy; 0x10uy; 0x34uy; 0x18uy; 0x0duy; 0xc9uy; 0x9fuy; 0x7buy; 0x0cuy; 0x9buy; 0x8fuy; 0x91uy; 0x1buy; 0x9fuy; 0xcduy; 0x10uy; 0xeeuy; 0x75uy; 0xf9uy; 0x97uy; 0x66uy; 0xfcuy; 0x4duy; 0x33uy; 0x6euy; 0x28uy; 0x2buy; 0x92uy; 0x85uy; 0x4fuy; 0xabuy; 0x43uy; 0x8duy; 0x8fuy; 0x7duy; 0x86uy; 0xa7uy; 0xc7uy; 0xd8uy; 0xd3uy; 0x0buy; 0x8buy; 0x57uy; 0xb6uy; 0x1duy; 0x95uy; 0x0duy; 0xe9uy; 0xbcuy; 0xd9uy; 0x03uy; 0xd9uy; 0x10uy; 0x19uy; 0xc3uy; 0x46uy; 0x63uy; 0x55uy; 0x87uy; 0x61uy; 0x79uy; 0x6cuy; 0x95uy; 0x0euy; 0x9cuy; 0xdduy; 0xcauy; 0xc3uy; 0xf3uy; 0x64uy; 0xf0uy; 0x7duy; 0x76uy; 0xb7uy; 0x53uy; 0x67uy; 0x2buy; 0x1euy; 0x44uy; 0x56uy; 0x81uy; 0xeauy; 0x8fuy; 0x5cuy; 0x42uy; 0x16uy; 0xb8uy; 0x28uy; 0xebuy; 0x1buy; 0x61uy; 0x10uy; 0x1euy; 0xbfuy; 0xecuy; 0xa8uy; ] in assert_norm (List.Tot.length l = 1933); B.gcmalloc_of_list HyperStack.root l	{ "file_name": "providers/test/vectors/Test.Vectors.Chacha20Poly1305.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 38, "end_line": 434, "start_col": 0, "start_line": 431 }	module Test.Vectors.Chacha20Poly1305 module B = LowStar.Buffer #set-options "--max_fuel 0 --max_ifuel 0" let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x1cuy; 0x92uy; 0x40uy; 0xa5uy; 0xebuy; 0x55uy; 0xd3uy; 0x8auy; 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x04uy; 0xf6uy; 0xb5uy; 0xf0uy; 0x47uy; 0x39uy; 0x17uy; 0xc1uy; 0x40uy; 0x2buy; 0x80uy; 0x09uy; 0x9duy; 0xcauy; 0x5cuy; 0xbcuy; 0x20uy; 0x70uy; 0x75uy; 0xc0uy; ] 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 nonce0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce0_len: (x:UInt32.t { UInt32.v x = B.length nonce0 }) = 12ul let aad0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x4euy; 0x91uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad0_len: (x:UInt32.t { UInt32.v x = B.length aad0 }) = 12ul let input0: (b: B.buffer UInt8.t { B.length b = 265 /\ B.recallable b /\ B.disjoint b aad0 }) = B.recall aad0;[@inline_let] let l = [ 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x72uy; 0x65uy; 0x20uy; 0x64uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x76uy; 0x61uy; 0x6cuy; 0x69uy; 0x64uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x61uy; 0x20uy; 0x6duy; 0x61uy; 0x78uy; 0x69uy; 0x6duy; 0x75uy; 0x6duy; 0x20uy; 0x6fuy; 0x66uy; 0x20uy; 0x73uy; 0x69uy; 0x78uy; 0x20uy; 0x6duy; 0x6fuy; 0x6euy; 0x74uy; 0x68uy; 0x73uy; 0x20uy; 0x61uy; 0x6euy; 0x64uy; 0x20uy; 0x6duy; 0x61uy; 0x79uy; 0x20uy; 0x62uy; 0x65uy; 0x20uy; 0x75uy; 0x70uy; 0x64uy; 0x61uy; 0x74uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x72uy; 0x65uy; 0x70uy; 0x6cuy; 0x61uy; 0x63uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x6fuy; 0x62uy; 0x73uy; 0x6fuy; 0x6cuy; 0x65uy; 0x74uy; 0x65uy; 0x64uy; 0x20uy; 0x62uy; 0x79uy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x74uy; 0x20uy; 0x61uy; 0x6euy; 0x79uy; 0x20uy; 0x74uy; 0x69uy; 0x6duy; 0x65uy; 0x2euy; 0x20uy; 0x49uy; 0x74uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x6euy; 0x61uy; 0x70uy; 0x70uy; 0x72uy; 0x6fuy; 0x70uy; 0x72uy; 0x69uy; 0x61uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x75uy; 0x73uy; 0x65uy; 0x20uy; 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x72uy; 0x65uy; 0x66uy; 0x65uy; 0x72uy; 0x65uy; 0x6euy; 0x63uy; 0x65uy; 0x20uy; 0x6duy; 0x61uy; 0x74uy; 0x65uy; 0x72uy; 0x69uy; 0x61uy; 0x6cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x63uy; 0x69uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x68uy; 0x65uy; 0x6duy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x74uy; 0x68uy; 0x61uy; 0x6euy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x2fuy; 0xe2uy; 0x80uy; 0x9cuy; 0x77uy; 0x6fuy; 0x72uy; 0x6buy; 0x20uy; 0x69uy; 0x6euy; 0x20uy; 0x70uy; 0x72uy; 0x6fuy; 0x67uy; 0x72uy; 0x65uy; 0x73uy; 0x73uy; 0x2euy; 0x2fuy; 0xe2uy; 0x80uy; 0x9duy; ] in assert_norm (List.Tot.length l = 265); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) = 265ul let output0: (b: B.buffer UInt8.t { B.length b = 281 /\ B.recallable b }) = [@inline_let] let l = [ 0x64uy; 0xa0uy; 0x86uy; 0x15uy; 0x75uy; 0x86uy; 0x1auy; 0xf4uy; 0x60uy; 0xf0uy; 0x62uy; 0xc7uy; 0x9buy; 0xe6uy; 0x43uy; 0xbduy; 0x5euy; 0x80uy; 0x5cuy; 0xfduy; 0x34uy; 0x5cuy; 0xf3uy; 0x89uy; 0xf1uy; 0x08uy; 0x67uy; 0x0auy; 0xc7uy; 0x6cuy; 0x8cuy; 0xb2uy; 0x4cuy; 0x6cuy; 0xfcuy; 0x18uy; 0x75uy; 0x5duy; 0x43uy; 0xeeuy; 0xa0uy; 0x9euy; 0xe9uy; 0x4euy; 0x38uy; 0x2duy; 0x26uy; 0xb0uy; 0xbduy; 0xb7uy; 0xb7uy; 0x3cuy; 0x32uy; 0x1buy; 0x01uy; 0x00uy; 0xd4uy; 0xf0uy; 0x3buy; 0x7fuy; 0x35uy; 0x58uy; 0x94uy; 0xcfuy; 0x33uy; 0x2fuy; 0x83uy; 0x0euy; 0x71uy; 0x0buy; 0x97uy; 0xceuy; 0x98uy; 0xc8uy; 0xa8uy; 0x4auy; 0xbduy; 0x0buy; 0x94uy; 0x81uy; 0x14uy; 0xaduy; 0x17uy; 0x6euy; 0x00uy; 0x8duy; 0x33uy; 0xbduy; 0x60uy; 0xf9uy; 0x82uy; 0xb1uy; 0xffuy; 0x37uy; 0xc8uy; 0x55uy; 0x97uy; 0x97uy; 0xa0uy; 0x6euy; 0xf4uy; 0xf0uy; 0xefuy; 0x61uy; 0xc1uy; 0x86uy; 0x32uy; 0x4euy; 0x2buy; 0x35uy; 0x06uy; 0x38uy; 0x36uy; 0x06uy; 0x90uy; 0x7buy; 0x6auy; 0x7cuy; 0x02uy; 0xb0uy; 0xf9uy; 0xf6uy; 0x15uy; 0x7buy; 0x53uy; 0xc8uy; 0x67uy; 0xe4uy; 0xb9uy; 0x16uy; 0x6cuy; 0x76uy; 0x7buy; 0x80uy; 0x4duy; 0x46uy; 0xa5uy; 0x9buy; 0x52uy; 0x16uy; 0xcduy; 0xe7uy; 0xa4uy; 0xe9uy; 0x90uy; 0x40uy; 0xc5uy; 0xa4uy; 0x04uy; 0x33uy; 0x22uy; 0x5euy; 0xe2uy; 0x82uy; 0xa1uy; 0xb0uy; 0xa0uy; 0x6cuy; 0x52uy; 0x3euy; 0xafuy; 0x45uy; 0x34uy; 0xd7uy; 0xf8uy; 0x3fuy; 0xa1uy; 0x15uy; 0x5buy; 0x00uy; 0x47uy; 0x71uy; 0x8cuy; 0xbcuy; 0x54uy; 0x6auy; 0x0duy; 0x07uy; 0x2buy; 0x04uy; 0xb3uy; 0x56uy; 0x4euy; 0xeauy; 0x1buy; 0x42uy; 0x22uy; 0x73uy; 0xf5uy; 0x48uy; 0x27uy; 0x1auy; 0x0buy; 0xb2uy; 0x31uy; 0x60uy; 0x53uy; 0xfauy; 0x76uy; 0x99uy; 0x19uy; 0x55uy; 0xebuy; 0xd6uy; 0x31uy; 0x59uy; 0x43uy; 0x4euy; 0xceuy; 0xbbuy; 0x4euy; 0x46uy; 0x6duy; 0xaeuy; 0x5auy; 0x10uy; 0x73uy; 0xa6uy; 0x72uy; 0x76uy; 0x27uy; 0x09uy; 0x7auy; 0x10uy; 0x49uy; 0xe6uy; 0x17uy; 0xd9uy; 0x1duy; 0x36uy; 0x10uy; 0x94uy; 0xfauy; 0x68uy; 0xf0uy; 0xffuy; 0x77uy; 0x98uy; 0x71uy; 0x30uy; 0x30uy; 0x5buy; 0xeauy; 0xbauy; 0x2euy; 0xdauy; 0x04uy; 0xdfuy; 0x99uy; 0x7buy; 0x71uy; 0x4duy; 0x6cuy; 0x6fuy; 0x2cuy; 0x29uy; 0xa6uy; 0xaduy; 0x5cuy; 0xb4uy; 0x02uy; 0x2buy; 0x02uy; 0x70uy; 0x9buy; 0xeeuy; 0xaduy; 0x9duy; 0x67uy; 0x89uy; 0x0cuy; 0xbbuy; 0x22uy; 0x39uy; 0x23uy; 0x36uy; 0xfeuy; 0xa1uy; 0x85uy; 0x1fuy; 0x38uy; ] in assert_norm (List.Tot.length l = 281); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output0_len: (x:UInt32.t { UInt32.v x = B.length output0 }) = 281ul let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x4cuy; 0xf5uy; 0x96uy; 0x83uy; 0x38uy; 0xe6uy; 0xaeuy; 0x7fuy; 0x2duy; 0x29uy; 0x25uy; 0x76uy; 0xd5uy; 0x75uy; 0x27uy; 0x86uy; 0x91uy; 0x9auy; 0x27uy; 0x7auy; 0xfbuy; 0x46uy; 0xc5uy; 0xefuy; 0x94uy; 0x81uy; 0x79uy; 0x57uy; 0x14uy; 0x59uy; 0x40uy; 0x68uy; ] 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 nonce1: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcauy; 0xbfuy; 0x33uy; 0x71uy; 0x32uy; 0x45uy; 0x77uy; 0x8euy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce1_len: (x:UInt32.t { UInt32.v x = B.length nonce1 }) = 12ul let aad1: (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 aad1_len: (x:UInt32.t { UInt32.v x = B.length aad1 }) = 0ul let input1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad1 }) = B.recall aad1;[@inline_let] let l = [ ] in assert_norm (List.Tot.length l = 0); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) = 0ul let output1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xeauy; 0xe0uy; 0x1euy; 0x9euy; 0x2cuy; 0x91uy; 0xaauy; 0xe1uy; 0xdbuy; 0x5duy; 0x99uy; 0x3fuy; 0x8auy; 0xf7uy; 0x69uy; 0x92uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output1_len: (x:UInt32.t { UInt32.v x = B.length output1 }) = 16ul let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x2duy; 0xb0uy; 0x5duy; 0x40uy; 0xc8uy; 0xeduy; 0x44uy; 0x88uy; 0x34uy; 0xd1uy; 0x13uy; 0xafuy; 0x57uy; 0xa1uy; 0xebuy; 0x3auy; 0x2auy; 0x80uy; 0x51uy; 0x36uy; 0xecuy; 0x5buy; 0xbcuy; 0x08uy; 0x93uy; 0x84uy; 0x21uy; 0xb5uy; 0x13uy; 0x88uy; 0x3cuy; 0x0duy; ] 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 nonce2: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x3duy; 0x86uy; 0xb5uy; 0x6buy; 0xc8uy; 0xa3uy; 0x1fuy; 0x1duy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce2_len: (x:UInt32.t { UInt32.v x = B.length nonce2 }) = 12ul let aad2: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) = [@inline_let] let l = [ 0x33uy; 0x10uy; 0x41uy; 0x12uy; 0x1fuy; 0xf3uy; 0xd2uy; 0x6buy; ] in assert_norm (List.Tot.length l = 8); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad2_len: (x:UInt32.t { UInt32.v x = B.length aad2 }) = 8ul let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad2 }) = B.recall aad2;[@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 output2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xdduy; 0x6buy; 0x3buy; 0x82uy; 0xceuy; 0x5auy; 0xbduy; 0xd6uy; 0xa9uy; 0x35uy; 0x83uy; 0xd8uy; 0x8cuy; 0x3duy; 0x85uy; 0x77uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output2_len: (x:UInt32.t { UInt32.v x = B.length output2 }) = 16ul let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x4buy; 0x28uy; 0x4buy; 0xa3uy; 0x7buy; 0xbeuy; 0xe9uy; 0xf8uy; 0x31uy; 0x80uy; 0x82uy; 0xd7uy; 0xd8uy; 0xe8uy; 0xb5uy; 0xa1uy; 0xe2uy; 0x18uy; 0x18uy; 0x8auy; 0x9cuy; 0xfauy; 0xa3uy; 0x3duy; 0x25uy; 0x71uy; 0x3euy; 0x40uy; 0xbcuy; 0x54uy; 0x7auy; 0x3euy; ] 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 nonce3: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xd2uy; 0x32uy; 0x1fuy; 0x29uy; 0x28uy; 0xc6uy; 0xc4uy; 0xc4uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce3_len: (x:UInt32.t { UInt32.v x = B.length nonce3 }) = 12ul let aad3: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) = [@inline_let] let l = [ 0x6auy; 0xe2uy; 0xaduy; 0x3fuy; 0x88uy; 0x39uy; 0x5auy; 0x40uy; ] in assert_norm (List.Tot.length l = 8); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad3_len: (x:UInt32.t { UInt32.v x = B.length aad3 }) = 8ul let input3: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad3 }) = B.recall aad3;[@inline_let] let l = [ 0xa4uy; ] in assert_norm (List.Tot.length l = 1); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) = 1ul let output3: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) = [@inline_let] let l = [ 0xb7uy; 0x1buy; 0xb0uy; 0x73uy; 0x59uy; 0xb0uy; 0x84uy; 0xb2uy; 0x6duy; 0x8euy; 0xabuy; 0x94uy; 0x31uy; 0xa1uy; 0xaeuy; 0xacuy; 0x89uy; ] in assert_norm (List.Tot.length l = 17); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output3_len: (x:UInt32.t { UInt32.v x = B.length output3 }) = 17ul let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x66uy; 0xcauy; 0x9cuy; 0x23uy; 0x2auy; 0x4buy; 0x4buy; 0x31uy; 0x0euy; 0x92uy; 0x89uy; 0x8buy; 0xf4uy; 0x93uy; 0xc7uy; 0x87uy; 0x98uy; 0xa3uy; 0xd8uy; 0x39uy; 0xf8uy; 0xf4uy; 0xa7uy; 0x01uy; 0xc0uy; 0x2euy; 0x0auy; 0xa6uy; 0x7euy; 0x5auy; 0x78uy; 0x87uy; ] 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 nonce4: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x1cuy; 0xaauy; 0x5fuy; 0x9cuy; 0xbfuy; 0x92uy; 0x30uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce4_len: (x:UInt32.t { UInt32.v x = B.length nonce4 }) = 12ul let aad4: (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 aad4_len: (x:UInt32.t { UInt32.v x = B.length aad4 }) = 0ul let input4: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad4 }) = B.recall aad4;[@inline_let] let l = [ 0x2duy; ] in assert_norm (List.Tot.length l = 1); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) = 1ul let output4: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) = [@inline_let] let l = [ 0xbfuy; 0xe1uy; 0x5buy; 0x0buy; 0xdbuy; 0x6buy; 0xf5uy; 0x5euy; 0x6cuy; 0x5duy; 0x84uy; 0x44uy; 0x39uy; 0x81uy; 0xc1uy; 0x9cuy; 0xacuy; ] in assert_norm (List.Tot.length l = 17); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output4_len: (x:UInt32.t { UInt32.v x = B.length output4 }) = 17ul let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x68uy; 0x7buy; 0x8duy; 0x8euy; 0xe3uy; 0xc4uy; 0xdduy; 0xaeuy; 0xdfuy; 0x72uy; 0x7fuy; 0x53uy; 0x72uy; 0x25uy; 0x1euy; 0x78uy; 0x91uy; 0xcbuy; 0x69uy; 0x76uy; 0x1fuy; 0x49uy; 0x93uy; 0xf9uy; 0x6fuy; 0x21uy; 0xccuy; 0x39uy; 0x9cuy; 0xaduy; 0xb1uy; 0x01uy; ] 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 nonce5: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdfuy; 0x51uy; 0x84uy; 0x82uy; 0x42uy; 0x0cuy; 0x75uy; 0x9cuy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce5_len: (x:UInt32.t { UInt32.v x = B.length nonce5 }) = 12ul let aad5: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) = [@inline_let] let l = [ 0x70uy; 0xd3uy; 0x33uy; 0xf3uy; 0x8buy; 0x18uy; 0x0buy; ] in assert_norm (List.Tot.length l = 7); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad5_len: (x:UInt32.t { UInt32.v x = B.length aad5 }) = 7ul let input5: (b: B.buffer UInt8.t { B.length b = 129 /\ B.recallable b /\ B.disjoint b aad5 }) = B.recall aad5;[@inline_let] let l = [ 0x33uy; 0x2fuy; 0x94uy; 0xc1uy; 0xa4uy; 0xefuy; 0xccuy; 0x2auy; 0x5buy; 0xa6uy; 0xe5uy; 0x8fuy; 0x1duy; 0x40uy; 0xf0uy; 0x92uy; 0x3cuy; 0xd9uy; 0x24uy; 0x11uy; 0xa9uy; 0x71uy; 0xf9uy; 0x37uy; 0x14uy; 0x99uy; 0xfauy; 0xbeuy; 0xe6uy; 0x80uy; 0xdeuy; 0x50uy; 0xc9uy; 0x96uy; 0xd4uy; 0xb0uy; 0xecuy; 0x9euy; 0x17uy; 0xecuy; 0xd2uy; 0x5euy; 0x72uy; 0x99uy; 0xfcuy; 0x0auy; 0xe1uy; 0xcbuy; 0x48uy; 0xd2uy; 0x85uy; 0xdduy; 0x2fuy; 0x90uy; 0xe0uy; 0x66uy; 0x3buy; 0xe6uy; 0x20uy; 0x74uy; 0xbeuy; 0x23uy; 0x8fuy; 0xcbuy; 0xb4uy; 0xe4uy; 0xdauy; 0x48uy; 0x40uy; 0xa6uy; 0xd1uy; 0x1buy; 0xc7uy; 0x42uy; 0xceuy; 0x2fuy; 0x0cuy; 0xa6uy; 0x85uy; 0x6euy; 0x87uy; 0x37uy; 0x03uy; 0xb1uy; 0x7cuy; 0x25uy; 0x96uy; 0xa3uy; 0x05uy; 0xd8uy; 0xb0uy; 0xf4uy; 0xeduy; 0xeauy; 0xc2uy; 0xf0uy; 0x31uy; 0x98uy; 0x6cuy; 0xd1uy; 0x14uy; 0x25uy; 0xc0uy; 0xcbuy; 0x01uy; 0x74uy; 0xd0uy; 0x82uy; 0xf4uy; 0x36uy; 0xf5uy; 0x41uy; 0xd5uy; 0xdcuy; 0xcauy; 0xc5uy; 0xbbuy; 0x98uy; 0xfeuy; 0xfcuy; 0x69uy; 0x21uy; 0x70uy; 0xd8uy; 0xa4uy; 0x4buy; 0xc8uy; 0xdeuy; 0x8fuy; ] in assert_norm (List.Tot.length l = 129); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) = 129ul let output5: (b: B.buffer UInt8.t { B.length b = 145 /\ B.recallable b }) = [@inline_let] let l = [ 0x8buy; 0x06uy; 0xd3uy; 0x31uy; 0xb0uy; 0x93uy; 0x45uy; 0xb1uy; 0x75uy; 0x6euy; 0x26uy; 0xf9uy; 0x67uy; 0xbcuy; 0x90uy; 0x15uy; 0x81uy; 0x2cuy; 0xb5uy; 0xf0uy; 0xc6uy; 0x2buy; 0xc7uy; 0x8cuy; 0x56uy; 0xd1uy; 0xbfuy; 0x69uy; 0x6cuy; 0x07uy; 0xa0uy; 0xdauy; 0x65uy; 0x27uy; 0xc9uy; 0x90uy; 0x3duy; 0xefuy; 0x4buy; 0x11uy; 0x0fuy; 0x19uy; 0x07uy; 0xfduy; 0x29uy; 0x92uy; 0xd9uy; 0xc8uy; 0xf7uy; 0x99uy; 0x2euy; 0x4auy; 0xd0uy; 0xb8uy; 0x2cuy; 0xdcuy; 0x93uy; 0xf5uy; 0x9euy; 0x33uy; 0x78uy; 0xd1uy; 0x37uy; 0xc3uy; 0x66uy; 0xd7uy; 0x5euy; 0xbcuy; 0x44uy; 0xbfuy; 0x53uy; 0xa5uy; 0xbcuy; 0xc4uy; 0xcbuy; 0x7buy; 0x3auy; 0x8euy; 0x7fuy; 0x02uy; 0xbduy; 0xbbuy; 0xe7uy; 0xcauy; 0xa6uy; 0x6cuy; 0x6buy; 0x93uy; 0x21uy; 0x93uy; 0x10uy; 0x61uy; 0xe7uy; 0x69uy; 0xd0uy; 0x78uy; 0xf3uy; 0x07uy; 0x5auy; 0x1auy; 0x8fuy; 0x73uy; 0xaauy; 0xb1uy; 0x4euy; 0xd3uy; 0xdauy; 0x4fuy; 0xf3uy; 0x32uy; 0xe1uy; 0x66uy; 0x3euy; 0x6cuy; 0xc6uy; 0x13uy; 0xbauy; 0x06uy; 0x5buy; 0xfcuy; 0x6auy; 0xe5uy; 0x6fuy; 0x60uy; 0xfbuy; 0x07uy; 0x40uy; 0xb0uy; 0x8cuy; 0x9duy; 0x84uy; 0x43uy; 0x6buy; 0xc1uy; 0xf7uy; 0x8duy; 0x8duy; 0x31uy; 0xf7uy; 0x7auy; 0x39uy; 0x4duy; 0x8fuy; 0x9auy; 0xebuy; ] in assert_norm (List.Tot.length l = 145); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output5_len: (x:UInt32.t { UInt32.v x = B.length output5 }) = 145ul let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x8duy; 0xb8uy; 0x91uy; 0x48uy; 0xf0uy; 0xe7uy; 0x0auy; 0xbduy; 0xf9uy; 0x3fuy; 0xcduy; 0xd9uy; 0xa0uy; 0x1euy; 0x42uy; 0x4cuy; 0xe7uy; 0xdeuy; 0x25uy; 0x3duy; 0xa3uy; 0xd7uy; 0x05uy; 0x80uy; 0x8duy; 0xf2uy; 0x82uy; 0xacuy; 0x44uy; 0x16uy; 0x51uy; 0x01uy; ] 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 nonce6: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdeuy; 0x7buy; 0xefuy; 0xc3uy; 0x65uy; 0x1buy; 0x68uy; 0xb0uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce6_len: (x:UInt32.t { UInt32.v x = B.length nonce6 }) = 12ul let aad6: (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 aad6_len: (x:UInt32.t { UInt32.v x = B.length aad6 }) = 0ul let input6: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b /\ B.disjoint b aad6 }) = B.recall aad6;[@inline_let] let l = [ 0x9buy; 0x18uy; 0xdbuy; 0xdduy; 0x9auy; 0x0fuy; 0x3euy; 0xa5uy; 0x15uy; 0x17uy; 0xdeuy; 0xdfuy; 0x08uy; 0x9duy; 0x65uy; 0x0auy; 0x67uy; 0x30uy; 0x12uy; 0xe2uy; 0x34uy; 0x77uy; 0x4buy; 0xc1uy; 0xd9uy; 0xc6uy; 0x1fuy; 0xabuy; 0xc6uy; 0x18uy; 0x50uy; 0x17uy; 0xa7uy; 0x9duy; 0x3cuy; 0xa6uy; 0xc5uy; 0x35uy; 0x8cuy; 0x1cuy; 0xc0uy; 0xa1uy; 0x7cuy; 0x9fuy; 0x03uy; 0x89uy; 0xcauy; 0xe1uy; 0xe6uy; 0xe9uy; 0xd4uy; 0xd3uy; 0x88uy; 0xdbuy; 0xb4uy; 0x51uy; 0x9duy; 0xecuy; 0xb4uy; 0xfcuy; 0x52uy; 0xeeuy; 0x6duy; 0xf1uy; 0x75uy; 0x42uy; 0xc6uy; 0xfduy; 0xbduy; 0x7auy; 0x8euy; 0x86uy; 0xfcuy; 0x44uy; 0xb3uy; 0x4fuy; 0xf3uy; 0xeauy; 0x67uy; 0x5auy; 0x41uy; 0x13uy; 0xbauy; 0xb0uy; 0xdcuy; 0xe1uy; 0xd3uy; 0x2auy; 0x7cuy; 0x22uy; 0xb3uy; 0xcauy; 0xacuy; 0x6auy; 0x37uy; 0x98uy; 0x3euy; 0x1duy; 0x40uy; 0x97uy; 0xf7uy; 0x9buy; 0x1duy; 0x36uy; 0x6buy; 0xb3uy; 0x28uy; 0xbduy; 0x60uy; 0x82uy; 0x47uy; 0x34uy; 0xaauy; 0x2fuy; 0x7duy; 0xe9uy; 0xa8uy; 0x70uy; 0x81uy; 0x57uy; 0xd4uy; 0xb9uy; 0x77uy; 0x0auy; 0x9duy; 0x29uy; 0xa7uy; 0x84uy; 0x52uy; 0x4fuy; 0xc2uy; 0x4auy; 0x40uy; 0x3buy; 0x3cuy; 0xd4uy; 0xc9uy; 0x2auy; 0xdbuy; 0x4auy; 0x53uy; 0xc4uy; 0xbeuy; 0x80uy; 0xe9uy; 0x51uy; 0x7fuy; 0x8fuy; 0xc7uy; 0xa2uy; 0xceuy; 0x82uy; 0x5cuy; 0x91uy; 0x1euy; 0x74uy; 0xd9uy; 0xd0uy; 0xbduy; 0xd5uy; 0xf3uy; 0xfduy; 0xdauy; 0x4duy; 0x25uy; 0xb4uy; 0xbbuy; 0x2duy; 0xacuy; 0x2fuy; 0x3duy; 0x71uy; 0x85uy; 0x7buy; 0xcfuy; 0x3cuy; 0x7buy; 0x3euy; 0x0euy; 0x22uy; 0x78uy; 0x0cuy; 0x29uy; 0xbfuy; 0xe4uy; 0xf4uy; 0x57uy; 0xb3uy; 0xcbuy; 0x49uy; 0xa0uy; 0xfcuy; 0x1euy; 0x05uy; 0x4euy; 0x16uy; 0xbcuy; 0xd5uy; 0xa8uy; 0xa3uy; 0xeeuy; 0x05uy; 0x35uy; 0xc6uy; 0x7cuy; 0xabuy; 0x60uy; 0x14uy; 0x55uy; 0x1auy; 0x8euy; 0xc5uy; 0x88uy; 0x5duy; 0xd5uy; 0x81uy; 0xc2uy; 0x81uy; 0xa5uy; 0xc4uy; 0x60uy; 0xdbuy; 0xafuy; 0x77uy; 0x91uy; 0xe1uy; 0xceuy; 0xa2uy; 0x7euy; 0x7fuy; 0x42uy; 0xe3uy; 0xb0uy; 0x13uy; 0x1cuy; 0x1fuy; 0x25uy; 0x60uy; 0x21uy; 0xe2uy; 0x40uy; 0x5fuy; 0x99uy; 0xb7uy; 0x73uy; 0xecuy; 0x9buy; 0x2buy; 0xf0uy; 0x65uy; 0x11uy; 0xc8uy; 0xd0uy; 0x0auy; 0x9fuy; 0xd3uy; ] in assert_norm (List.Tot.length l = 256); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) = 256ul let output6: (b: B.buffer UInt8.t { B.length b = 272 /\ B.recallable b }) = [@inline_let] let l = [ 0x85uy; 0x04uy; 0xc2uy; 0xeduy; 0x8duy; 0xfduy; 0x97uy; 0x5cuy; 0xd2uy; 0xb7uy; 0xe2uy; 0xc1uy; 0x6buy; 0xa3uy; 0xbauy; 0xf8uy; 0xc9uy; 0x50uy; 0xc3uy; 0xc6uy; 0xa5uy; 0xe3uy; 0xa4uy; 0x7cuy; 0xc3uy; 0x23uy; 0x49uy; 0x5euy; 0xa9uy; 0xb9uy; 0x32uy; 0xebuy; 0x8auy; 0x7cuy; 0xcauy; 0xe5uy; 0xecuy; 0xfbuy; 0x7cuy; 0xc0uy; 0xcbuy; 0x7duy; 0xdcuy; 0x2cuy; 0x9duy; 0x92uy; 0x55uy; 0x21uy; 0x0auy; 0xc8uy; 0x43uy; 0x63uy; 0x59uy; 0x0auy; 0x31uy; 0x70uy; 0x82uy; 0x67uy; 0x41uy; 0x03uy; 0xf8uy; 0xdfuy; 0xf2uy; 0xacuy; 0xa7uy; 0x02uy; 0xd4uy; 0xd5uy; 0x8auy; 0x2duy; 0xc8uy; 0x99uy; 0x19uy; 0x66uy; 0xd0uy; 0xf6uy; 0x88uy; 0x2cuy; 0x77uy; 0xd9uy; 0xd4uy; 0x0duy; 0x6cuy; 0xbduy; 0x98uy; 0xdeuy; 0xe7uy; 0x7fuy; 0xaduy; 0x7euy; 0x8auy; 0xfbuy; 0xe9uy; 0x4buy; 0xe5uy; 0xf7uy; 0xe5uy; 0x50uy; 0xa0uy; 0x90uy; 0x3fuy; 0xd6uy; 0x22uy; 0x53uy; 0xe3uy; 0xfeuy; 0x1buy; 0xccuy; 0x79uy; 0x3buy; 0xecuy; 0x12uy; 0x47uy; 0x52uy; 0xa7uy; 0xd6uy; 0x04uy; 0xe3uy; 0x52uy; 0xe6uy; 0x93uy; 0x90uy; 0x91uy; 0x32uy; 0x73uy; 0x79uy; 0xb8uy; 0xd0uy; 0x31uy; 0xdeuy; 0x1fuy; 0x9fuy; 0x2fuy; 0x05uy; 0x38uy; 0x54uy; 0x2fuy; 0x35uy; 0x04uy; 0x39uy; 0xe0uy; 0xa7uy; 0xbauy; 0xc6uy; 0x52uy; 0xf6uy; 0x37uy; 0x65uy; 0x4cuy; 0x07uy; 0xa9uy; 0x7euy; 0xb3uy; 0x21uy; 0x6fuy; 0x74uy; 0x8cuy; 0xc9uy; 0xdeuy; 0xdbuy; 0x65uy; 0x1buy; 0x9buy; 0xaauy; 0x60uy; 0xb1uy; 0x03uy; 0x30uy; 0x6buy; 0xb2uy; 0x03uy; 0xc4uy; 0x1cuy; 0x04uy; 0xf8uy; 0x0fuy; 0x64uy; 0xafuy; 0x46uy; 0xe4uy; 0x65uy; 0x99uy; 0x49uy; 0xe2uy; 0xeauy; 0xceuy; 0x78uy; 0x00uy; 0xd8uy; 0x8buy; 0xd5uy; 0x2euy; 0xcfuy; 0xfcuy; 0x40uy; 0x49uy; 0xe8uy; 0x58uy; 0xdcuy; 0x34uy; 0x9cuy; 0x8cuy; 0x61uy; 0xbfuy; 0x0auy; 0x8euy; 0xecuy; 0x39uy; 0xa9uy; 0x30uy; 0x05uy; 0x5auy; 0xd2uy; 0x56uy; 0x01uy; 0xc7uy; 0xdauy; 0x8fuy; 0x4euy; 0xbbuy; 0x43uy; 0xa3uy; 0x3auy; 0xf9uy; 0x15uy; 0x2auy; 0xd0uy; 0xa0uy; 0x7auy; 0x87uy; 0x34uy; 0x82uy; 0xfeuy; 0x8auy; 0xd1uy; 0x2duy; 0x5euy; 0xc7uy; 0xbfuy; 0x04uy; 0x53uy; 0x5fuy; 0x3buy; 0x36uy; 0xd4uy; 0x25uy; 0x5cuy; 0x34uy; 0x7auy; 0x8duy; 0xd5uy; 0x05uy; 0xceuy; 0x72uy; 0xcauy; 0xefuy; 0x7auy; 0x4buy; 0xbcuy; 0xb0uy; 0x10uy; 0x5cuy; 0x96uy; 0x42uy; 0x3auy; 0x00uy; 0x98uy; 0xcduy; 0x15uy; 0xe8uy; 0xb7uy; 0x53uy; ] in assert_norm (List.Tot.length l = 272); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output6_len: (x:UInt32.t { UInt32.v x = B.length output6 }) = 272ul let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0xf2uy; 0xaauy; 0x4fuy; 0x99uy; 0xfduy; 0x3euy; 0xa8uy; 0x53uy; 0xc1uy; 0x44uy; 0xe9uy; 0x81uy; 0x18uy; 0xdcuy; 0xf5uy; 0xf0uy; 0x3euy; 0x44uy; 0x15uy; 0x59uy; 0xe0uy; 0xc5uy; 0x44uy; 0x86uy; 0xc3uy; 0x91uy; 0xa8uy; 0x75uy; 0xc0uy; 0x12uy; 0x46uy; 0xbauy; ] 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 nonce7: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0euy; 0x0duy; 0x57uy; 0xbbuy; 0x7buy; 0x40uy; 0x54uy; 0x02uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce7_len: (x:UInt32.t { UInt32.v x = B.length nonce7 }) = 12ul let aad7: (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 aad7_len: (x:UInt32.t { UInt32.v x = B.length aad7 }) = 0ul let input7: (b: B.buffer UInt8.t { B.length b = 512 /\ B.recallable b /\ B.disjoint b aad7 }) = B.recall aad7;[@inline_let] let l = [ 0xc3uy; 0x09uy; 0x94uy; 0x62uy; 0xe6uy; 0x46uy; 0x2euy; 0x10uy; 0xbeuy; 0x00uy; 0xe4uy; 0xfcuy; 0xf3uy; 0x40uy; 0xa3uy; 0xe2uy; 0x0fuy; 0xc2uy; 0x8buy; 0x28uy; 0xdcuy; 0xbauy; 0xb4uy; 0x3cuy; 0xe4uy; 0x21uy; 0x58uy; 0x61uy; 0xcduy; 0x8buy; 0xcduy; 0xfbuy; 0xacuy; 0x94uy; 0xa1uy; 0x45uy; 0xf5uy; 0x1cuy; 0xe1uy; 0x12uy; 0xe0uy; 0x3buy; 0x67uy; 0x21uy; 0x54uy; 0x5euy; 0x8cuy; 0xaauy; 0xcfuy; 0xdbuy; 0xb4uy; 0x51uy; 0xd4uy; 0x13uy; 0xdauy; 0xe6uy; 0x83uy; 0x89uy; 0xb6uy; 0x92uy; 0xe9uy; 0x21uy; 0x76uy; 0xa4uy; 0x93uy; 0x7duy; 0x0euy; 0xfduy; 0x96uy; 0x36uy; 0x03uy; 0x91uy; 0x43uy; 0x5cuy; 0x92uy; 0x49uy; 0x62uy; 0x61uy; 0x7buy; 0xebuy; 0x43uy; 0x89uy; 0xb8uy; 0x12uy; 0x20uy; 0x43uy; 0xd4uy; 0x47uy; 0x06uy; 0x84uy; 0xeeuy; 0x47uy; 0xe9uy; 0x8auy; 0x73uy; 0x15uy; 0x0fuy; 0x72uy; 0xcfuy; 0xeduy; 0xceuy; 0x96uy; 0xb2uy; 0x7fuy; 0x21uy; 0x45uy; 0x76uy; 0xebuy; 0x26uy; 0x28uy; 0x83uy; 0x6auy; 0xaduy; 0xaauy; 0xa6uy; 0x81uy; 0xd8uy; 0x55uy; 0xb1uy; 0xa3uy; 0x85uy; 0xb3uy; 0x0cuy; 0xdfuy; 0xf1uy; 0x69uy; 0x2duy; 0x97uy; 0x05uy; 0x2auy; 0xbcuy; 0x7cuy; 0x7buy; 0x25uy; 0xf8uy; 0x80uy; 0x9duy; 0x39uy; 0x25uy; 0xf3uy; 0x62uy; 0xf0uy; 0x66uy; 0x5euy; 0xf4uy; 0xa0uy; 0xcfuy; 0xd8uy; 0xfduy; 0x4fuy; 0xb1uy; 0x1fuy; 0x60uy; 0x3auy; 0x08uy; 0x47uy; 0xafuy; 0xe1uy; 0xf6uy; 0x10uy; 0x77uy; 0x09uy; 0xa7uy; 0x27uy; 0x8fuy; 0x9auy; 0x97uy; 0x5auy; 0x26uy; 0xfauy; 0xfeuy; 0x41uy; 0x32uy; 0x83uy; 0x10uy; 0xe0uy; 0x1duy; 0xbfuy; 0x64uy; 0x0duy; 0xf4uy; 0x1cuy; 0x32uy; 0x35uy; 0xe5uy; 0x1buy; 0x36uy; 0xefuy; 0xd4uy; 0x4auy; 0x93uy; 0x4duy; 0x00uy; 0x7cuy; 0xecuy; 0x02uy; 0x07uy; 0x8buy; 0x5duy; 0x7duy; 0x1buy; 0x0euy; 0xd1uy; 0xa6uy; 0xa5uy; 0x5duy; 0x7duy; 0x57uy; 0x88uy; 0xa8uy; 0xccuy; 0x81uy; 0xb4uy; 0x86uy; 0x4euy; 0xb4uy; 0x40uy; 0xe9uy; 0x1duy; 0xc3uy; 0xb1uy; 0x24uy; 0x3euy; 0x7fuy; 0xccuy; 0x8auy; 0x24uy; 0x9buy; 0xdfuy; 0x6duy; 0xf0uy; 0x39uy; 0x69uy; 0x3euy; 0x4cuy; 0xc0uy; 0x96uy; 0xe4uy; 0x13uy; 0xdauy; 0x90uy; 0xdauy; 0xf4uy; 0x95uy; 0x66uy; 0x8buy; 0x17uy; 0x17uy; 0xfeuy; 0x39uy; 0x43uy; 0x25uy; 0xaauy; 0xdauy; 0xa0uy; 0x43uy; 0x3cuy; 0xb1uy; 0x41uy; 0x02uy; 0xa3uy; 0xf0uy; 0xa7uy; 0x19uy; 0x59uy; 0xbcuy; 0x1duy; 0x7duy; 0x6cuy; 0x6duy; 0x91uy; 0x09uy; 0x5cuy; 0xb7uy; 0x5buy; 0x01uy; 0xd1uy; 0x6fuy; 0x17uy; 0x21uy; 0x97uy; 0xbfuy; 0x89uy; 0x71uy; 0xa5uy; 0xb0uy; 0x6euy; 0x07uy; 0x45uy; 0xfduy; 0x9duy; 0xeauy; 0x07uy; 0xf6uy; 0x7auy; 0x9fuy; 0x10uy; 0x18uy; 0x22uy; 0x30uy; 0x73uy; 0xacuy; 0xd4uy; 0x6buy; 0x72uy; 0x44uy; 0xeduy; 0xd9uy; 0x19uy; 0x9buy; 0x2duy; 0x4auy; 0x41uy; 0xdduy; 0xd1uy; 0x85uy; 0x5euy; 0x37uy; 0x19uy; 0xeduy; 0xd2uy; 0x15uy; 0x8fuy; 0x5euy; 0x91uy; 0xdbuy; 0x33uy; 0xf2uy; 0xe4uy; 0xdbuy; 0xffuy; 0x98uy; 0xfbuy; 0xa3uy; 0xb5uy; 0xcauy; 0x21uy; 0x69uy; 0x08uy; 0xe7uy; 0x8auy; 0xdfuy; 0x90uy; 0xffuy; 0x3euy; 0xe9uy; 0x20uy; 0x86uy; 0x3cuy; 0xe9uy; 0xfcuy; 0x0buy; 0xfeuy; 0x5cuy; 0x61uy; 0xaauy; 0x13uy; 0x92uy; 0x7fuy; 0x7buy; 0xecuy; 0xe0uy; 0x6duy; 0xa8uy; 0x23uy; 0x22uy; 0xf6uy; 0x6buy; 0x77uy; 0xc4uy; 0xfeuy; 0x40uy; 0x07uy; 0x3buy; 0xb6uy; 0xf6uy; 0x8euy; 0x5fuy; 0xd4uy; 0xb9uy; 0xb7uy; 0x0fuy; 0x21uy; 0x04uy; 0xefuy; 0x83uy; 0x63uy; 0x91uy; 0x69uy; 0x40uy; 0xa3uy; 0x48uy; 0x5cuy; 0xd2uy; 0x60uy; 0xf9uy; 0x4fuy; 0x6cuy; 0x47uy; 0x8buy; 0x3buy; 0xb1uy; 0x9fuy; 0x8euy; 0xeeuy; 0x16uy; 0x8auy; 0x13uy; 0xfcuy; 0x46uy; 0x17uy; 0xc3uy; 0xc3uy; 0x32uy; 0x56uy; 0xf8uy; 0x3cuy; 0x85uy; 0x3auy; 0xb6uy; 0x3euy; 0xaauy; 0x89uy; 0x4fuy; 0xb3uy; 0xdfuy; 0x38uy; 0xfduy; 0xf1uy; 0xe4uy; 0x3auy; 0xc0uy; 0xe6uy; 0x58uy; 0xb5uy; 0x8fuy; 0xc5uy; 0x29uy; 0xa2uy; 0x92uy; 0x4auy; 0xb6uy; 0xa0uy; 0x34uy; 0x7fuy; 0xabuy; 0xb5uy; 0x8auy; 0x90uy; 0xa1uy; 0xdbuy; 0x4duy; 0xcauy; 0xb6uy; 0x2cuy; 0x41uy; 0x3cuy; 0xf7uy; 0x2buy; 0x21uy; 0xc3uy; 0xfduy; 0xf4uy; 0x17uy; 0x5cuy; 0xb5uy; 0x33uy; 0x17uy; 0x68uy; 0x2buy; 0x08uy; 0x30uy; 0xf3uy; 0xf7uy; 0x30uy; 0x3cuy; 0x96uy; 0xe6uy; 0x6auy; 0x20uy; 0x97uy; 0xe7uy; 0x4duy; 0x10uy; 0x5fuy; 0x47uy; 0x5fuy; 0x49uy; 0x96uy; 0x09uy; 0xf0uy; 0x27uy; 0x91uy; 0xc8uy; 0xf8uy; 0x5auy; 0x2euy; 0x79uy; 0xb5uy; 0xe2uy; 0xb8uy; 0xe8uy; 0xb9uy; 0x7buy; 0xd5uy; 0x10uy; 0xcbuy; 0xffuy; 0x5duy; 0x14uy; 0x73uy; 0xf3uy; ] in assert_norm (List.Tot.length l = 512); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) = 512ul let output7: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) = [@inline_let] let l = [ 0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy; 0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy; 0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy; 0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy; 0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy; 0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy; 0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy; 0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy; 0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy; 0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy; 0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy; 0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy; 0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy; 0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy; 0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy; 0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy; 0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy; 0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy; 0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy; 0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy; 0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy; 0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy; 0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy; 0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy; 0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy; 0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy; 0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy; 0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy; 0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy; 0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy; 0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy; 0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy; 0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy; 0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy; 0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy; 0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy; 0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy; 0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy; 0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy; 0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy; 0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy; 0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy; 0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy; 0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy; ] in assert_norm (List.Tot.length l = 528); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output7_len: (x:UInt32.t { UInt32.v x = B.length output7 }) = 528ul let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0xeauy; 0xbcuy; 0x56uy; 0x99uy; 0xe3uy; 0x50uy; 0xffuy; 0xc5uy; 0xccuy; 0x1auy; 0xd7uy; 0xc1uy; 0x57uy; 0x72uy; 0xeauy; 0x86uy; 0x5buy; 0x89uy; 0x88uy; 0x61uy; 0x3duy; 0x2fuy; 0x9buy; 0xb2uy; 0xe7uy; 0x9cuy; 0xecuy; 0x74uy; 0x6euy; 0x3euy; 0xf4uy; 0x3buy; ] 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 nonce8: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xefuy; 0x2duy; 0x63uy; 0xeeuy; 0x6buy; 0x80uy; 0x8buy; 0x78uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce8_len: (x:UInt32.t { UInt32.v x = B.length nonce8 }) = 12ul let aad8: (b: B.buffer UInt8.t { B.length b = 9 /\ B.recallable b }) = [@inline_let] let l = [ 0x5auy; 0x27uy; 0xffuy; 0xebuy; 0xdfuy; 0x84uy; 0xb2uy; 0x9euy; 0xefuy; ] in assert_norm (List.Tot.length l = 9); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad8_len: (x:UInt32.t { UInt32.v x = B.length aad8 }) = 9ul let input8: (b: B.buffer UInt8.t { B.length b = 513 /\ B.recallable b /\ B.disjoint b aad8 }) = B.recall aad8;[@inline_let] let l = [ 0xe6uy; 0xc3uy; 0xdbuy; 0x63uy; 0x55uy; 0x15uy; 0xe3uy; 0x5buy; 0xb7uy; 0x4buy; 0x27uy; 0x8buy; 0x5auy; 0xdduy; 0xc2uy; 0xe8uy; 0x3auy; 0x6buy; 0xd7uy; 0x81uy; 0x96uy; 0x35uy; 0x97uy; 0xcauy; 0xd7uy; 0x68uy; 0xe8uy; 0xefuy; 0xceuy; 0xabuy; 0xdauy; 0x09uy; 0x6euy; 0xd6uy; 0x8euy; 0xcbuy; 0x55uy; 0xb5uy; 0xe1uy; 0xe5uy; 0x57uy; 0xfduy; 0xc4uy; 0xe3uy; 0xe0uy; 0x18uy; 0x4fuy; 0x85uy; 0xf5uy; 0x3fuy; 0x7euy; 0x4buy; 0x88uy; 0xc9uy; 0x52uy; 0x44uy; 0x0fuy; 0xeauy; 0xafuy; 0x1fuy; 0x71uy; 0x48uy; 0x9fuy; 0x97uy; 0x6duy; 0xb9uy; 0x6fuy; 0x00uy; 0xa6uy; 0xdeuy; 0x2buy; 0x77uy; 0x8buy; 0x15uy; 0xaduy; 0x10uy; 0xa0uy; 0x2buy; 0x7buy; 0x41uy; 0x90uy; 0x03uy; 0x2duy; 0x69uy; 0xaeuy; 0xccuy; 0x77uy; 0x7cuy; 0xa5uy; 0x9duy; 0x29uy; 0x22uy; 0xc2uy; 0xeauy; 0xb4uy; 0x00uy; 0x1auy; 0xd2uy; 0x7auy; 0x98uy; 0x8auy; 0xf9uy; 0xf7uy; 0x82uy; 0xb0uy; 0xabuy; 0xd8uy; 0xa6uy; 0x94uy; 0x8duy; 0x58uy; 0x2fuy; 0x01uy; 0x9euy; 0x00uy; 0x20uy; 0xfcuy; 0x49uy; 0xdcuy; 0x0euy; 0x03uy; 0xe8uy; 0x45uy; 0x10uy; 0xd6uy; 0xa8uy; 0xdauy; 0x55uy; 0x10uy; 0x9auy; 0xdfuy; 0x67uy; 0x22uy; 0x8buy; 0x43uy; 0xabuy; 0x00uy; 0xbbuy; 0x02uy; 0xc8uy; 0xdduy; 0x7buy; 0x97uy; 0x17uy; 0xd7uy; 0x1duy; 0x9euy; 0x02uy; 0x5euy; 0x48uy; 0xdeuy; 0x8euy; 0xcfuy; 0x99uy; 0x07uy; 0x95uy; 0x92uy; 0x3cuy; 0x5fuy; 0x9fuy; 0xc5uy; 0x8auy; 0xc0uy; 0x23uy; 0xaauy; 0xd5uy; 0x8cuy; 0x82uy; 0x6euy; 0x16uy; 0x92uy; 0xb1uy; 0x12uy; 0x17uy; 0x07uy; 0xc3uy; 0xfbuy; 0x36uy; 0xf5uy; 0x6cuy; 0x35uy; 0xd6uy; 0x06uy; 0x1fuy; 0x9fuy; 0xa7uy; 0x94uy; 0xa2uy; 0x38uy; 0x63uy; 0x9cuy; 0xb0uy; 0x71uy; 0xb3uy; 0xa5uy; 0xd2uy; 0xd8uy; 0xbauy; 0x9fuy; 0x08uy; 0x01uy; 0xb3uy; 0xffuy; 0x04uy; 0x97uy; 0x73uy; 0x45uy; 0x1buy; 0xd5uy; 0xa9uy; 0x9cuy; 0x80uy; 0xafuy; 0x04uy; 0x9auy; 0x85uy; 0xdbuy; 0x32uy; 0x5buy; 0x5duy; 0x1auy; 0xc1uy; 0x36uy; 0x28uy; 0x10uy; 0x79uy; 0xf1uy; 0x3cuy; 0xbfuy; 0x1auy; 0x41uy; 0x5cuy; 0x4euy; 0xdfuy; 0xb2uy; 0x7cuy; 0x79uy; 0x3buy; 0x7auy; 0x62uy; 0x3duy; 0x4buy; 0xc9uy; 0x9buy; 0x2auy; 0x2euy; 0x7cuy; 0xa2uy; 0xb1uy; 0x11uy; 0x98uy; 0xa7uy; 0x34uy; 0x1auy; 0x00uy; 0xf3uy; 0xd1uy; 0xbcuy; 0x18uy; 0x22uy; 0xbauy; 0x02uy; 0x56uy; 0x62uy; 0x31uy; 0x10uy; 0x11uy; 0x6duy; 0xe0uy; 0x54uy; 0x9duy; 0x40uy; 0x1fuy; 0x26uy; 0x80uy; 0x41uy; 0xcauy; 0x3fuy; 0x68uy; 0x0fuy; 0x32uy; 0x1duy; 0x0auy; 0x8euy; 0x79uy; 0xd8uy; 0xa4uy; 0x1buy; 0x29uy; 0x1cuy; 0x90uy; 0x8euy; 0xc5uy; 0xe3uy; 0xb4uy; 0x91uy; 0x37uy; 0x9auy; 0x97uy; 0x86uy; 0x99uy; 0xd5uy; 0x09uy; 0xc5uy; 0xbbuy; 0xa3uy; 0x3fuy; 0x21uy; 0x29uy; 0x82uy; 0x14uy; 0x5cuy; 0xabuy; 0x25uy; 0xfbuy; 0xf2uy; 0x4fuy; 0x58uy; 0x26uy; 0xd4uy; 0x83uy; 0xaauy; 0x66uy; 0x89uy; 0x67uy; 0x7euy; 0xc0uy; 0x49uy; 0xe1uy; 0x11uy; 0x10uy; 0x7fuy; 0x7auy; 0xdauy; 0x29uy; 0x04uy; 0xffuy; 0xf0uy; 0xcbuy; 0x09uy; 0x7cuy; 0x9duy; 0xfauy; 0x03uy; 0x6fuy; 0x81uy; 0x09uy; 0x31uy; 0x60uy; 0xfbuy; 0x08uy; 0xfauy; 0x74uy; 0xd3uy; 0x64uy; 0x44uy; 0x7cuy; 0x55uy; 0x85uy; 0xecuy; 0x9cuy; 0x6euy; 0x25uy; 0xb7uy; 0x6cuy; 0xc5uy; 0x37uy; 0xb6uy; 0x83uy; 0x87uy; 0x72uy; 0x95uy; 0x8buy; 0x9duy; 0xe1uy; 0x69uy; 0x5cuy; 0x31uy; 0x95uy; 0x42uy; 0xa6uy; 0x2cuy; 0xd1uy; 0x36uy; 0x47uy; 0x1fuy; 0xecuy; 0x54uy; 0xabuy; 0xa2uy; 0x1cuy; 0xd8uy; 0x00uy; 0xccuy; 0xbcuy; 0x0duy; 0x65uy; 0xe2uy; 0x67uy; 0xbfuy; 0xbcuy; 0xeauy; 0xeeuy; 0x9euy; 0xe4uy; 0x36uy; 0x95uy; 0xbeuy; 0x73uy; 0xd9uy; 0xa6uy; 0xd9uy; 0x0fuy; 0xa0uy; 0xccuy; 0x82uy; 0x76uy; 0x26uy; 0xaduy; 0x5buy; 0x58uy; 0x6cuy; 0x4euy; 0xabuy; 0x29uy; 0x64uy; 0xd3uy; 0xd9uy; 0xa9uy; 0x08uy; 0x8cuy; 0x1duy; 0xa1uy; 0x4fuy; 0x80uy; 0xd8uy; 0x3fuy; 0x94uy; 0xfbuy; 0xd3uy; 0x7buy; 0xfcuy; 0xd1uy; 0x2buy; 0xc3uy; 0x21uy; 0xebuy; 0xe5uy; 0x1cuy; 0x84uy; 0x23uy; 0x7fuy; 0x4buy; 0xfauy; 0xdbuy; 0x34uy; 0x18uy; 0xa2uy; 0xc2uy; 0xe5uy; 0x13uy; 0xfeuy; 0x6cuy; 0x49uy; 0x81uy; 0xd2uy; 0x73uy; 0xe7uy; 0xe2uy; 0xd7uy; 0xe4uy; 0x4fuy; 0x4buy; 0x08uy; 0x6euy; 0xb1uy; 0x12uy; 0x22uy; 0x10uy; 0x9duy; 0xacuy; 0x51uy; 0x1euy; 0x17uy; 0xd9uy; 0x8auy; 0x0buy; 0x42uy; 0x88uy; 0x16uy; 0x81uy; 0x37uy; 0x7cuy; 0x6auy; 0xf7uy; 0xefuy; 0x2duy; 0xe3uy; 0xd9uy; 0xf8uy; 0x5fuy; 0xe0uy; 0x53uy; 0x27uy; 0x74uy; 0xb9uy; 0xe2uy; 0xd6uy; 0x1cuy; 0x80uy; 0x2cuy; 0x52uy; 0x65uy; ] in assert_norm (List.Tot.length l = 513); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) = 513ul let output8: (b: B.buffer UInt8.t { B.length b = 529 /\ B.recallable b }) = [@inline_let] let l = [ 0xfduy; 0x81uy; 0x8duy; 0xd0uy; 0x3duy; 0xb4uy; 0xd5uy; 0xdfuy; 0xd3uy; 0x42uy; 0x47uy; 0x5auy; 0x6duy; 0x19uy; 0x27uy; 0x66uy; 0x4buy; 0x2euy; 0x0cuy; 0x27uy; 0x9cuy; 0x96uy; 0x4cuy; 0x72uy; 0x02uy; 0xa3uy; 0x65uy; 0xc3uy; 0xb3uy; 0x6fuy; 0x2euy; 0xbduy; 0x63uy; 0x8auy; 0x4auy; 0x5duy; 0x29uy; 0xa2uy; 0xd0uy; 0x28uy; 0x48uy; 0xc5uy; 0x3duy; 0x98uy; 0xa3uy; 0xbcuy; 0xe0uy; 0xbeuy; 0x3buy; 0x3fuy; 0xe6uy; 0x8auy; 0xa4uy; 0x7fuy; 0x53uy; 0x06uy; 0xfauy; 0x7fuy; 0x27uy; 0x76uy; 0x72uy; 0x31uy; 0xa1uy; 0xf5uy; 0xd6uy; 0x0cuy; 0x52uy; 0x47uy; 0xbauy; 0xcduy; 0x4fuy; 0xd7uy; 0xebuy; 0x05uy; 0x48uy; 0x0duy; 0x7cuy; 0x35uy; 0x4auy; 0x09uy; 0xc9uy; 0x76uy; 0x71uy; 0x02uy; 0xa3uy; 0xfbuy; 0xb7uy; 0x1auy; 0x65uy; 0xb7uy; 0xeduy; 0x98uy; 0xc6uy; 0x30uy; 0x8auy; 0x00uy; 0xaeuy; 0xa1uy; 0x31uy; 0xe5uy; 0xb5uy; 0x9euy; 0x6duy; 0x62uy; 0xdauy; 0xdauy; 0x07uy; 0x0fuy; 0x38uy; 0x38uy; 0xd3uy; 0xcbuy; 0xc1uy; 0xb0uy; 0xaduy; 0xecuy; 0x72uy; 0xecuy; 0xb1uy; 0xa2uy; 0x7buy; 0x59uy; 0xf3uy; 0x3duy; 0x2buy; 0xefuy; 0xcduy; 0x28uy; 0x5buy; 0x83uy; 0xccuy; 0x18uy; 0x91uy; 0x88uy; 0xb0uy; 0x2euy; 0xf9uy; 0x29uy; 0x31uy; 0x18uy; 0xf9uy; 0x4euy; 0xe9uy; 0x0auy; 0x91uy; 0x92uy; 0x9fuy; 0xaeuy; 0x2duy; 0xaduy; 0xf4uy; 0xe6uy; 0x1auy; 0xe2uy; 0xa4uy; 0xeeuy; 0x47uy; 0x15uy; 0xbfuy; 0x83uy; 0x6euy; 0xd7uy; 0x72uy; 0x12uy; 0x3buy; 0x2duy; 0x24uy; 0xe9uy; 0xb2uy; 0x55uy; 0xcbuy; 0x3cuy; 0x10uy; 0xf0uy; 0x24uy; 0x8auy; 0x4auy; 0x02uy; 0xeauy; 0x90uy; 0x25uy; 0xf0uy; 0xb4uy; 0x79uy; 0x3auy; 0xefuy; 0x6euy; 0xf5uy; 0x52uy; 0xdfuy; 0xb0uy; 0x0auy; 0xcduy; 0x24uy; 0x1cuy; 0xd3uy; 0x2euy; 0x22uy; 0x74uy; 0xeauy; 0x21uy; 0x6fuy; 0xe9uy; 0xbduy; 0xc8uy; 0x3euy; 0x36uy; 0x5buy; 0x19uy; 0xf1uy; 0xcauy; 0x99uy; 0x0auy; 0xb4uy; 0xa7uy; 0x52uy; 0x1auy; 0x4euy; 0xf2uy; 0xaduy; 0x8duy; 0x56uy; 0x85uy; 0xbbuy; 0x64uy; 0x89uy; 0xbauy; 0x26uy; 0xf9uy; 0xc7uy; 0xe1uy; 0x89uy; 0x19uy; 0x22uy; 0x77uy; 0xc3uy; 0xa8uy; 0xfcuy; 0xffuy; 0xaduy; 0xfeuy; 0xb9uy; 0x48uy; 0xaeuy; 0x12uy; 0x30uy; 0x9fuy; 0x19uy; 0xfbuy; 0x1buy; 0xefuy; 0x14uy; 0x87uy; 0x8auy; 0x78uy; 0x71uy; 0xf3uy; 0xf4uy; 0xb7uy; 0x00uy; 0x9cuy; 0x1duy; 0xb5uy; 0x3duy; 0x49uy; 0x00uy; 0x0cuy; 0x06uy; 0xd4uy; 0x50uy; 0xf9uy; 0x54uy; 0x45uy; 0xb2uy; 0x5buy; 0x43uy; 0xdbuy; 0x6duy; 0xcfuy; 0x1auy; 0xe9uy; 0x7auy; 0x7auy; 0xcfuy; 0xfcuy; 0x8auy; 0x4euy; 0x4duy; 0x0buy; 0x07uy; 0x63uy; 0x28uy; 0xd8uy; 0xe7uy; 0x08uy; 0x95uy; 0xdfuy; 0xa6uy; 0x72uy; 0x93uy; 0x2euy; 0xbbuy; 0xa0uy; 0x42uy; 0x89uy; 0x16uy; 0xf1uy; 0xd9uy; 0x0cuy; 0xf9uy; 0xa1uy; 0x16uy; 0xfduy; 0xd9uy; 0x03uy; 0xb4uy; 0x3buy; 0x8auy; 0xf5uy; 0xf6uy; 0xe7uy; 0x6buy; 0x2euy; 0x8euy; 0x4cuy; 0x3duy; 0xe2uy; 0xafuy; 0x08uy; 0x45uy; 0x03uy; 0xffuy; 0x09uy; 0xb6uy; 0xebuy; 0x2duy; 0xc6uy; 0x1buy; 0x88uy; 0x94uy; 0xacuy; 0x3euy; 0xf1uy; 0x9fuy; 0x0euy; 0x0euy; 0x2buy; 0xd5uy; 0x00uy; 0x4duy; 0x3fuy; 0x3buy; 0x53uy; 0xaeuy; 0xafuy; 0x1cuy; 0x33uy; 0x5fuy; 0x55uy; 0x6euy; 0x8duy; 0xafuy; 0x05uy; 0x7auy; 0x10uy; 0x34uy; 0xc9uy; 0xf4uy; 0x66uy; 0xcbuy; 0x62uy; 0x12uy; 0xa6uy; 0xeeuy; 0xe8uy; 0x1cuy; 0x5duy; 0x12uy; 0x86uy; 0xdbuy; 0x6fuy; 0x1cuy; 0x33uy; 0xc4uy; 0x1cuy; 0xdauy; 0x82uy; 0x2duy; 0x3buy; 0x59uy; 0xfeuy; 0xb1uy; 0xa4uy; 0x59uy; 0x41uy; 0x86uy; 0xd0uy; 0xefuy; 0xaeuy; 0xfbuy; 0xdauy; 0x6duy; 0x11uy; 0xb8uy; 0xcauy; 0xe9uy; 0x6euy; 0xffuy; 0xf7uy; 0xa9uy; 0xd9uy; 0x70uy; 0x30uy; 0xfcuy; 0x53uy; 0xe2uy; 0xd7uy; 0xa2uy; 0x4euy; 0xc7uy; 0x91uy; 0xd9uy; 0x07uy; 0x06uy; 0xaauy; 0xdduy; 0xb0uy; 0x59uy; 0x28uy; 0x1duy; 0x00uy; 0x66uy; 0xc5uy; 0x54uy; 0xc2uy; 0xfcuy; 0x06uy; 0xdauy; 0x05uy; 0x90uy; 0x52uy; 0x1duy; 0x37uy; 0x66uy; 0xeeuy; 0xf0uy; 0xb2uy; 0x55uy; 0x8auy; 0x5duy; 0xd2uy; 0x38uy; 0x86uy; 0x94uy; 0x9buy; 0xfcuy; 0x10uy; 0x4cuy; 0xa1uy; 0xb9uy; 0x64uy; 0x3euy; 0x44uy; 0xb8uy; 0x5fuy; 0xb0uy; 0x0cuy; 0xecuy; 0xe0uy; 0xc9uy; 0xe5uy; 0x62uy; 0x75uy; 0x3fuy; 0x09uy; 0xd5uy; 0xf5uy; 0xd9uy; 0x26uy; 0xbauy; 0x9euy; 0xd2uy; 0xf4uy; 0xb9uy; 0x48uy; 0x0auy; 0xbcuy; 0xa2uy; 0xd6uy; 0x7cuy; 0x36uy; 0x11uy; 0x7duy; 0x26uy; 0x81uy; 0x89uy; 0xcfuy; 0xa4uy; 0xaduy; 0x73uy; 0x0euy; 0xeeuy; 0xccuy; 0x06uy; 0xa9uy; 0xdbuy; 0xb1uy; 0xfduy; 0xfbuy; 0x09uy; 0x7fuy; 0x90uy; 0x42uy; 0x37uy; 0x2fuy; 0xe1uy; 0x9cuy; 0x0fuy; 0x6fuy; 0xcfuy; 0x43uy; 0xb5uy; 0xd9uy; 0x90uy; 0xe1uy; 0x85uy; 0xf5uy; 0xa8uy; 0xaeuy; ] in assert_norm (List.Tot.length l = 529); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output8_len: (x:UInt32.t { UInt32.v x = B.length output8 }) = 529ul let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x47uy; 0x11uy; 0xebuy; 0x86uy; 0x2buy; 0x2cuy; 0xabuy; 0x44uy; 0x34uy; 0xdauy; 0x7fuy; 0x57uy; 0x03uy; 0x39uy; 0x0cuy; 0xafuy; 0x2cuy; 0x14uy; 0xfduy; 0x65uy; 0x23uy; 0xe9uy; 0x8euy; 0x74uy; 0xd5uy; 0x08uy; 0x68uy; 0x08uy; 0xe7uy; 0xb4uy; 0x72uy; 0xd7uy; ] 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 nonce9: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdbuy; 0x92uy; 0x0fuy; 0x7fuy; 0x17uy; 0x54uy; 0x0cuy; 0x30uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce9_len: (x:UInt32.t { UInt32.v x = B.length nonce9 }) = 12ul let aad9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xd2uy; 0xa1uy; 0x70uy; 0xdbuy; 0x7auy; 0xf8uy; 0xfauy; 0x27uy; 0xbauy; 0x73uy; 0x0fuy; 0xbfuy; 0x3duy; 0x1euy; 0x82uy; 0xb2uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad9_len: (x:UInt32.t { UInt32.v x = B.length aad9 }) = 16ul let input9: (b: B.buffer UInt8.t { B.length b = 1024 /\ B.recallable b /\ B.disjoint b aad9 }) = B.recall aad9;[@inline_let] let l = [ 0x42uy; 0x93uy; 0xe4uy; 0xebuy; 0x97uy; 0xb0uy; 0x57uy; 0xbfuy; 0x1auy; 0x8buy; 0x1fuy; 0xe4uy; 0x5fuy; 0x36uy; 0x20uy; 0x3cuy; 0xefuy; 0x0auy; 0xa9uy; 0x48uy; 0x5fuy; 0x5fuy; 0x37uy; 0x22uy; 0x3auy; 0xdeuy; 0xe3uy; 0xaeuy; 0xbeuy; 0xaduy; 0x07uy; 0xccuy; 0xb1uy; 0xf6uy; 0xf5uy; 0xf9uy; 0x56uy; 0xdduy; 0xe7uy; 0x16uy; 0x1euy; 0x7fuy; 0xdfuy; 0x7auy; 0x9euy; 0x75uy; 0xb7uy; 0xc7uy; 0xbeuy; 0xbeuy; 0x8auy; 0x36uy; 0x04uy; 0xc0uy; 0x10uy; 0xf4uy; 0x95uy; 0x20uy; 0x03uy; 0xecuy; 0xdcuy; 0x05uy; 0xa1uy; 0x7duy; 0xc4uy; 0xa9uy; 0x2cuy; 0x82uy; 0xd0uy; 0xbcuy; 0x8buy; 0xc5uy; 0xc7uy; 0x45uy; 0x50uy; 0xf6uy; 0xa2uy; 0x1auy; 0xb5uy; 0x46uy; 0x3buy; 0x73uy; 0x02uy; 0xa6uy; 0x83uy; 0x4buy; 0x73uy; 0x82uy; 0x58uy; 0x5euy; 0x3buy; 0x65uy; 0x2fuy; 0x0euy; 0xfduy; 0x2buy; 0x59uy; 0x16uy; 0xceuy; 0xa1uy; 0x60uy; 0x9cuy; 0xe8uy; 0x3auy; 0x99uy; 0xeduy; 0x8duy; 0x5auy; 0xcfuy; 0xf6uy; 0x83uy; 0xafuy; 0xbauy; 0xd7uy; 0x73uy; 0x73uy; 0x40uy; 0x97uy; 0x3duy; 0xcauy; 0xefuy; 0x07uy; 0x57uy; 0xe6uy; 0xd9uy; 0x70uy; 0x0euy; 0x95uy; 0xaeuy; 0xa6uy; 0x8duy; 0x04uy; 0xccuy; 0xeeuy; 0xf7uy; 0x09uy; 0x31uy; 0x77uy; 0x12uy; 0xa3uy; 0x23uy; 0x97uy; 0x62uy; 0xb3uy; 0x7buy; 0x32uy; 0xfbuy; 0x80uy; 0x14uy; 0x48uy; 0x81uy; 0xc3uy; 0xe5uy; 0xeauy; 0x91uy; 0x39uy; 0x52uy; 0x81uy; 0xa2uy; 0x4fuy; 0xe4uy; 0xb3uy; 0x09uy; 0xffuy; 0xdeuy; 0x5euy; 0xe9uy; 0x58uy; 0x84uy; 0x6euy; 0xf9uy; 0x3duy; 0xdfuy; 0x25uy; 0xeauy; 0xaduy; 0xaeuy; 0xe6uy; 0x9auy; 0xd1uy; 0x89uy; 0x55uy; 0xd3uy; 0xdeuy; 0x6cuy; 0x52uy; 0xdbuy; 0x70uy; 0xfeuy; 0x37uy; 0xceuy; 0x44uy; 0x0auy; 0xa8uy; 0x25uy; 0x5fuy; 0x92uy; 0xc1uy; 0x33uy; 0x4auy; 0x4fuy; 0x9buy; 0x62uy; 0x35uy; 0xffuy; 0xceuy; 0xc0uy; 0xa9uy; 0x60uy; 0xceuy; 0x52uy; 0x00uy; 0x97uy; 0x51uy; 0x35uy; 0x26uy; 0x2euy; 0xb9uy; 0x36uy; 0xa9uy; 0x87uy; 0x6euy; 0x1euy; 0xccuy; 0x91uy; 0x78uy; 0x53uy; 0x98uy; 0x86uy; 0x5buy; 0x9cuy; 0x74uy; 0x7duy; 0x88uy; 0x33uy; 0xe1uy; 0xdfuy; 0x37uy; 0x69uy; 0x2buy; 0xbbuy; 0xf1uy; 0x4duy; 0xf4uy; 0xd1uy; 0xf1uy; 0x39uy; 0x93uy; 0x17uy; 0x51uy; 0x19uy; 0xe3uy; 0x19uy; 0x1euy; 0x76uy; 0x37uy; 0x25uy; 0xfbuy; 0x09uy; 0x27uy; 0x6auy; 0xabuy; 0x67uy; 0x6fuy; 0x14uy; 0x12uy; 0x64uy; 0xe7uy; 0xc4uy; 0x07uy; 0xdfuy; 0x4duy; 0x17uy; 0xbbuy; 0x6duy; 0xe0uy; 0xe9uy; 0xb9uy; 0xabuy; 0xcauy; 0x10uy; 0x68uy; 0xafuy; 0x7euy; 0xb7uy; 0x33uy; 0x54uy; 0x73uy; 0x07uy; 0x6euy; 0xf7uy; 0x81uy; 0x97uy; 0x9cuy; 0x05uy; 0x6fuy; 0x84uy; 0x5fuy; 0xd2uy; 0x42uy; 0xfbuy; 0x38uy; 0xcfuy; 0xd1uy; 0x2fuy; 0x14uy; 0x30uy; 0x88uy; 0x98uy; 0x4duy; 0x5auy; 0xa9uy; 0x76uy; 0xd5uy; 0x4fuy; 0x3euy; 0x70uy; 0x6cuy; 0x85uy; 0x76uy; 0xd7uy; 0x01uy; 0xa0uy; 0x1auy; 0xc8uy; 0x4euy; 0xaauy; 0xacuy; 0x78uy; 0xfeuy; 0x46uy; 0xdeuy; 0x6auy; 0x05uy; 0x46uy; 0xa7uy; 0x43uy; 0x0cuy; 0xb9uy; 0xdeuy; 0xb9uy; 0x68uy; 0xfbuy; 0xceuy; 0x42uy; 0x99uy; 0x07uy; 0x4duy; 0x0buy; 0x3buy; 0x5auy; 0x30uy; 0x35uy; 0xa8uy; 0xf9uy; 0x3auy; 0x73uy; 0xefuy; 0x0fuy; 0xdbuy; 0x1euy; 0x16uy; 0x42uy; 0xc4uy; 0xbauy; 0xaeuy; 0x58uy; 0xaauy; 0xf8uy; 0xe5uy; 0x75uy; 0x2fuy; 0x1buy; 0x15uy; 0x5cuy; 0xfduy; 0x0auy; 0x97uy; 0xd0uy; 0xe4uy; 0x37uy; 0x83uy; 0x61uy; 0x5fuy; 0x43uy; 0xa6uy; 0xc7uy; 0x3fuy; 0x38uy; 0x59uy; 0xe6uy; 0xebuy; 0xa3uy; 0x90uy; 0xc3uy; 0xaauy; 0xaauy; 0x5auy; 0xd3uy; 0x34uy; 0xd4uy; 0x17uy; 0xc8uy; 0x65uy; 0x3euy; 0x57uy; 0xbcuy; 0x5euy; 0xdduy; 0x9euy; 0xb7uy; 0xf0uy; 0x2euy; 0x5buy; 0xb2uy; 0x1fuy; 0x8auy; 0x08uy; 0x0duy; 0x45uy; 0x91uy; 0x0buy; 0x29uy; 0x53uy; 0x4fuy; 0x4cuy; 0x5auy; 0x73uy; 0x56uy; 0xfeuy; 0xafuy; 0x41uy; 0x01uy; 0x39uy; 0x0auy; 0x24uy; 0x3cuy; 0x7euy; 0xbeuy; 0x4euy; 0x53uy; 0xf3uy; 0xebuy; 0x06uy; 0x66uy; 0x51uy; 0x28uy; 0x1duy; 0xbduy; 0x41uy; 0x0auy; 0x01uy; 0xabuy; 0x16uy; 0x47uy; 0x27uy; 0x47uy; 0x47uy; 0xf7uy; 0xcbuy; 0x46uy; 0x0auy; 0x70uy; 0x9euy; 0x01uy; 0x9cuy; 0x09uy; 0xe1uy; 0x2auy; 0x00uy; 0x1auy; 0xd8uy; 0xd4uy; 0x79uy; 0x9duy; 0x80uy; 0x15uy; 0x8euy; 0x53uy; 0x2auy; 0x65uy; 0x83uy; 0x78uy; 0x3euy; 0x03uy; 0x00uy; 0x07uy; 0x12uy; 0x1fuy; 0x33uy; 0x3euy; 0x7buy; 0x13uy; 0x37uy; 0xf1uy; 0xc3uy; 0xefuy; 0xb7uy; 0xc1uy; 0x20uy; 0x3cuy; 0x3euy; 0x67uy; 0x66uy; 0x5duy; 0x88uy; 0xa7uy; 0x7duy; 0x33uy; 0x50uy; 0x77uy; 0xb0uy; 0x28uy; 0x8euy; 0xe7uy; 0x2cuy; 0x2euy; 0x7auy; 0xf4uy; 0x3cuy; 0x8duy; 0x74uy; 0x83uy; 0xafuy; 0x8euy; 0x87uy; 0x0fuy; 0xe4uy; 0x50uy; 0xffuy; 0x84uy; 0x5cuy; 0x47uy; 0x0cuy; 0x6auy; 0x49uy; 0xbfuy; 0x42uy; 0x86uy; 0x77uy; 0x15uy; 0x48uy; 0xa5uy; 0x90uy; 0x5duy; 0x93uy; 0xd6uy; 0x2auy; 0x11uy; 0xd5uy; 0xd5uy; 0x11uy; 0xaauy; 0xceuy; 0xe7uy; 0x6fuy; 0xa5uy; 0xb0uy; 0x09uy; 0x2cuy; 0x8duy; 0xd3uy; 0x92uy; 0xf0uy; 0x5auy; 0x2auy; 0xdauy; 0x5buy; 0x1euy; 0xd5uy; 0x9auy; 0xc4uy; 0xc4uy; 0xf3uy; 0x49uy; 0x74uy; 0x41uy; 0xcauy; 0xe8uy; 0xc1uy; 0xf8uy; 0x44uy; 0xd6uy; 0x3cuy; 0xaeuy; 0x6cuy; 0x1duy; 0x9auy; 0x30uy; 0x04uy; 0x4duy; 0x27uy; 0x0euy; 0xb1uy; 0x5fuy; 0x59uy; 0xa2uy; 0x24uy; 0xe8uy; 0xe1uy; 0x98uy; 0xc5uy; 0x6auy; 0x4cuy; 0xfeuy; 0x41uy; 0xd2uy; 0x27uy; 0x42uy; 0x52uy; 0xe1uy; 0xe9uy; 0x7duy; 0x62uy; 0xe4uy; 0x88uy; 0x0fuy; 0xaduy; 0xb2uy; 0x70uy; 0xcbuy; 0x9duy; 0x4cuy; 0x27uy; 0x2euy; 0x76uy; 0x1euy; 0x1auy; 0x63uy; 0x65uy; 0xf5uy; 0x3buy; 0xf8uy; 0x57uy; 0x69uy; 0xebuy; 0x5buy; 0x38uy; 0x26uy; 0x39uy; 0x33uy; 0x25uy; 0x45uy; 0x3euy; 0x91uy; 0xb8uy; 0xd8uy; 0xc7uy; 0xd5uy; 0x42uy; 0xc0uy; 0x22uy; 0x31uy; 0x74uy; 0xf4uy; 0xbcuy; 0x0cuy; 0x23uy; 0xf1uy; 0xcauy; 0xc1uy; 0x8duy; 0xd7uy; 0xbeuy; 0xc9uy; 0x62uy; 0xe4uy; 0x08uy; 0x1auy; 0xcfuy; 0x36uy; 0xd5uy; 0xfeuy; 0x55uy; 0x21uy; 0x59uy; 0x91uy; 0x87uy; 0x87uy; 0xdfuy; 0x06uy; 0xdbuy; 0xdfuy; 0x96uy; 0x45uy; 0x58uy; 0xdauy; 0x05uy; 0xcduy; 0x50uy; 0x4duy; 0xd2uy; 0x7duy; 0x05uy; 0x18uy; 0x73uy; 0x6auy; 0x8duy; 0x11uy; 0x85uy; 0xa6uy; 0x88uy; 0xe8uy; 0xdauy; 0xe6uy; 0x30uy; 0x33uy; 0xa4uy; 0x89uy; 0x31uy; 0x75uy; 0xbeuy; 0x69uy; 0x43uy; 0x84uy; 0x43uy; 0x50uy; 0x87uy; 0xdduy; 0x71uy; 0x36uy; 0x83uy; 0xc3uy; 0x78uy; 0x74uy; 0x24uy; 0x0auy; 0xeduy; 0x7buy; 0xdbuy; 0xa4uy; 0x24uy; 0x0buy; 0xb9uy; 0x7euy; 0x5duy; 0xffuy; 0xdeuy; 0xb1uy; 0xefuy; 0x61uy; 0x5auy; 0x45uy; 0x33uy; 0xf6uy; 0x17uy; 0x07uy; 0x08uy; 0x98uy; 0x83uy; 0x92uy; 0x0fuy; 0x23uy; 0x6duy; 0xe6uy; 0xaauy; 0x17uy; 0x54uy; 0xaduy; 0x6auy; 0xc8uy; 0xdbuy; 0x26uy; 0xbeuy; 0xb8uy; 0xb6uy; 0x08uy; 0xfauy; 0x68uy; 0xf1uy; 0xd7uy; 0x79uy; 0x6fuy; 0x18uy; 0xb4uy; 0x9euy; 0x2duy; 0x3fuy; 0x1buy; 0x64uy; 0xafuy; 0x8duy; 0x06uy; 0x0euy; 0x49uy; 0x28uy; 0xe0uy; 0x5duy; 0x45uy; 0x68uy; 0x13uy; 0x87uy; 0xfauy; 0xdeuy; 0x40uy; 0x7buy; 0xd2uy; 0xc3uy; 0x94uy; 0xd5uy; 0xe1uy; 0xd9uy; 0xc2uy; 0xafuy; 0x55uy; 0x89uy; 0xebuy; 0xb4uy; 0x12uy; 0x59uy; 0xa8uy; 0xd4uy; 0xc5uy; 0x29uy; 0x66uy; 0x38uy; 0xe6uy; 0xacuy; 0x22uy; 0x22uy; 0xd9uy; 0x64uy; 0x9buy; 0x34uy; 0x0auy; 0x32uy; 0x9fuy; 0xc2uy; 0xbfuy; 0x17uy; 0x6cuy; 0x3fuy; 0x71uy; 0x7auy; 0x38uy; 0x6buy; 0x98uy; 0xfbuy; 0x49uy; 0x36uy; 0x89uy; 0xc9uy; 0xe2uy; 0xd6uy; 0xc7uy; 0x5duy; 0xd0uy; 0x69uy; 0x5fuy; 0x23uy; 0x35uy; 0xc9uy; 0x30uy; 0xe2uy; 0xfduy; 0x44uy; 0x58uy; 0x39uy; 0xd7uy; 0x97uy; 0xfbuy; 0x5cuy; 0x00uy; 0xd5uy; 0x4fuy; 0x7auy; 0x1auy; 0x95uy; 0x8buy; 0x62uy; 0x4buy; 0xceuy; 0xe5uy; 0x91uy; 0x21uy; 0x7buy; 0x30uy; 0x00uy; 0xd6uy; 0xdduy; 0x6duy; 0x02uy; 0x86uy; 0x49uy; 0x0fuy; 0x3cuy; 0x1auy; 0x27uy; 0x3cuy; 0xd3uy; 0x0euy; 0x71uy; 0xf2uy; 0xffuy; 0xf5uy; 0x2fuy; 0x87uy; 0xacuy; 0x67uy; 0x59uy; 0x81uy; 0xa3uy; 0xf7uy; 0xf8uy; 0xd6uy; 0x11uy; 0x0cuy; 0x84uy; 0xa9uy; 0x03uy; 0xeeuy; 0x2auy; 0xc4uy; 0xf3uy; 0x22uy; 0xabuy; 0x7cuy; 0xe2uy; 0x25uy; 0xf5uy; 0x67uy; 0xa3uy; 0xe4uy; 0x11uy; 0xe0uy; 0x59uy; 0xb3uy; 0xcauy; 0x87uy; 0xa0uy; 0xaeuy; 0xc9uy; 0xa6uy; 0x62uy; 0x1buy; 0x6euy; 0x4duy; 0x02uy; 0x6buy; 0x07uy; 0x9duy; 0xfduy; 0xd0uy; 0x92uy; 0x06uy; 0xe1uy; 0xb2uy; 0x9auy; 0x4auy; 0x1fuy; 0x1fuy; 0x13uy; 0x49uy; 0x99uy; 0x97uy; 0x08uy; 0xdeuy; 0x7fuy; 0x98uy; 0xafuy; 0x51uy; 0x98uy; 0xeeuy; 0x2cuy; 0xcbuy; 0xf0uy; 0x0buy; 0xc6uy; 0xb6uy; 0xb7uy; 0x2duy; 0x9auy; 0xb1uy; 0xacuy; 0xa6uy; 0xe3uy; 0x15uy; 0x77uy; 0x9duy; 0x6buy; 0x1auy; 0xe4uy; 0xfcuy; 0x8buy; 0xf2uy; 0x17uy; 0x59uy; 0x08uy; 0x04uy; 0x58uy; 0x81uy; 0x9duy; 0x1buy; 0x1buy; 0x69uy; 0x55uy; 0xc2uy; 0xb4uy; 0x3cuy; 0x1fuy; 0x50uy; 0xf1uy; 0x7fuy; 0x77uy; 0x90uy; 0x4cuy; 0x66uy; 0x40uy; 0x5auy; 0xc0uy; 0x33uy; 0x1fuy; 0xcbuy; 0x05uy; 0x6duy; 0x5cuy; 0x06uy; 0x87uy; 0x52uy; 0xa2uy; 0x8fuy; 0x26uy; 0xd5uy; 0x4fuy; ] in assert_norm (List.Tot.length l = 1024); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) = 1024ul let output9: (b: B.buffer UInt8.t { B.length b = 1040 /\ B.recallable b }) = [@inline_let] let l = [ 0xe5uy; 0x26uy; 0xa4uy; 0x3duy; 0xbduy; 0x33uy; 0xd0uy; 0x4buy; 0x6fuy; 0x05uy; 0xa7uy; 0x6euy; 0x12uy; 0x7auy; 0xd2uy; 0x74uy; 0xa6uy; 0xdduy; 0xbduy; 0x95uy; 0xebuy; 0xf9uy; 0xa4uy; 0xf1uy; 0x59uy; 0x93uy; 0x91uy; 0x70uy; 0xd9uy; 0xfeuy; 0x9auy; 0xcduy; 0x53uy; 0x1fuy; 0x3auy; 0xabuy; 0xa6uy; 0x7cuy; 0x9fuy; 0xa6uy; 0x9euy; 0xbduy; 0x99uy; 0xd9uy; 0xb5uy; 0x97uy; 0x44uy; 0xd5uy; 0x14uy; 0x48uy; 0x4duy; 0x9duy; 0xc0uy; 0xd0uy; 0x05uy; 0x96uy; 0xebuy; 0x4cuy; 0x78uy; 0x55uy; 0x09uy; 0x08uy; 0x01uy; 0x02uy; 0x30uy; 0x90uy; 0x7buy; 0x96uy; 0x7auy; 0x7buy; 0x5fuy; 0x30uy; 0x41uy; 0x24uy; 0xceuy; 0x68uy; 0x61uy; 0x49uy; 0x86uy; 0x57uy; 0x82uy; 0xdduy; 0x53uy; 0x1cuy; 0x51uy; 0x28uy; 0x2buy; 0x53uy; 0x6euy; 0x2duy; 0xc2uy; 0x20uy; 0x4cuy; 0xdduy; 0x8fuy; 0x65uy; 0x10uy; 0x20uy; 0x50uy; 0xdduy; 0x9duy; 0x50uy; 0xe5uy; 0x71uy; 0x40uy; 0x53uy; 0x69uy; 0xfcuy; 0x77uy; 0x48uy; 0x11uy; 0xb9uy; 0xdeuy; 0xa4uy; 0x8duy; 0x58uy; 0xe4uy; 0xa6uy; 0x1auy; 0x18uy; 0x47uy; 0x81uy; 0x7euy; 0xfcuy; 0xdduy; 0xf6uy; 0xefuy; 0xceuy; 0x2fuy; 0x43uy; 0x68uy; 0xd6uy; 0x06uy; 0xe2uy; 0x74uy; 0x6auy; 0xaduy; 0x90uy; 0xf5uy; 0x37uy; 0xf3uy; 0x3duy; 0x82uy; 0x69uy; 0x40uy; 0xe9uy; 0x6buy; 0xa7uy; 0x3duy; 0xa8uy; 0x1euy; 0xd2uy; 0x02uy; 0x7cuy; 0xb7uy; 0x9buy; 0xe4uy; 0xdauy; 0x8fuy; 0x95uy; 0x06uy; 0xc5uy; 0xdfuy; 0x73uy; 0xa3uy; 0x20uy; 0x9auy; 0x49uy; 0xdeuy; 0x9cuy; 0xbcuy; 0xeeuy; 0x14uy; 0x3fuy; 0x81uy; 0x5euy; 0xf8uy; 0x3buy; 0x59uy; 0x3cuy; 0xe1uy; 0x68uy; 0x12uy; 0x5auy; 0x3auy; 0x76uy; 0x3auy; 0x3fuy; 0xf7uy; 0x87uy; 0x33uy; 0x0auy; 0x01uy; 0xb8uy; 0xd4uy; 0xeduy; 0xb6uy; 0xbeuy; 0x94uy; 0x5euy; 0x70uy; 0x40uy; 0x56uy; 0x67uy; 0x1fuy; 0x50uy; 0x44uy; 0x19uy; 0xceuy; 0x82uy; 0x70uy; 0x10uy; 0x87uy; 0x13uy; 0x20uy; 0x0buy; 0x4cuy; 0x5auy; 0xb6uy; 0xf6uy; 0xa7uy; 0xaeuy; 0x81uy; 0x75uy; 0x01uy; 0x81uy; 0xe6uy; 0x4buy; 0x57uy; 0x7cuy; 0xdduy; 0x6duy; 0xf8uy; 0x1cuy; 0x29uy; 0x32uy; 0xf7uy; 0xdauy; 0x3cuy; 0x2duy; 0xf8uy; 0x9buy; 0x25uy; 0x6euy; 0x00uy; 0xb4uy; 0xf7uy; 0x2fuy; 0xf7uy; 0x04uy; 0xf7uy; 0xa1uy; 0x56uy; 0xacuy; 0x4fuy; 0x1auy; 0x64uy; 0xb8uy; 0x47uy; 0x55uy; 0x18uy; 0x7buy; 0x07uy; 0x4duy; 0xbduy; 0x47uy; 0x24uy; 0x80uy; 0x5duy; 0xa2uy; 0x70uy; 0xc5uy; 0xdduy; 0x8euy; 0x82uy; 0xd4uy; 0xebuy; 0xecuy; 0xb2uy; 0x0cuy; 0x39uy; 0xd2uy; 0x97uy; 0xc1uy; 0xcbuy; 0xebuy; 0xf4uy; 0x77uy; 0x59uy; 0xb4uy; 0x87uy; 0xefuy; 0xcbuy; 0x43uy; 0x2duy; 0x46uy; 0x54uy; 0xd1uy; 0xa7uy; 0xd7uy; 0x15uy; 0x99uy; 0x0auy; 0x43uy; 0xa1uy; 0xe0uy; 0x99uy; 0x33uy; 0x71uy; 0xc1uy; 0xeduy; 0xfeuy; 0x72uy; 0x46uy; 0x33uy; 0x8euy; 0x91uy; 0x08uy; 0x9fuy; 0xc8uy; 0x2euy; 0xcauy; 0xfauy; 0xdcuy; 0x59uy; 0xd5uy; 0xc3uy; 0x76uy; 0x84uy; 0x9fuy; 0xa3uy; 0x37uy; 0x68uy; 0xc3uy; 0xf0uy; 0x47uy; 0x2cuy; 0x68uy; 0xdbuy; 0x5euy; 0xc3uy; 0x49uy; 0x4cuy; 0xe8uy; 0x92uy; 0x85uy; 0xe2uy; 0x23uy; 0xd3uy; 0x3fuy; 0xaduy; 0x32uy; 0xe5uy; 0x2buy; 0x82uy; 0xd7uy; 0x8fuy; 0x99uy; 0x0auy; 0x59uy; 0x5cuy; 0x45uy; 0xd9uy; 0xb4uy; 0x51uy; 0x52uy; 0xc2uy; 0xaeuy; 0xbfuy; 0x80uy; 0xcfuy; 0xc9uy; 0xc9uy; 0x51uy; 0x24uy; 0x2auy; 0x3buy; 0x3auy; 0x4duy; 0xaeuy; 0xebuy; 0xbduy; 0x22uy; 0xc3uy; 0x0euy; 0x0fuy; 0x59uy; 0x25uy; 0x92uy; 0x17uy; 0xe9uy; 0x74uy; 0xc7uy; 0x8buy; 0x70uy; 0x70uy; 0x36uy; 0x55uy; 0x95uy; 0x75uy; 0x4buy; 0xaduy; 0x61uy; 0x2buy; 0x09uy; 0xbcuy; 0x82uy; 0xf2uy; 0x6euy; 0x94uy; 0x43uy; 0xaeuy; 0xc3uy; 0xd5uy; 0xcduy; 0x8euy; 0xfeuy; 0x5buy; 0x9auy; 0x88uy; 0x43uy; 0x01uy; 0x75uy; 0xb2uy; 0x23uy; 0x09uy; 0xf7uy; 0x89uy; 0x83uy; 0xe7uy; 0xfauy; 0xf9uy; 0xb4uy; 0x9buy; 0xf8uy; 0xefuy; 0xbduy; 0x1cuy; 0x92uy; 0xc1uy; 0xdauy; 0x7euy; 0xfeuy; 0x05uy; 0xbauy; 0x5auy; 0xcduy; 0x07uy; 0x6auy; 0x78uy; 0x9euy; 0x5duy; 0xfbuy; 0x11uy; 0x2fuy; 0x79uy; 0x38uy; 0xb6uy; 0xc2uy; 0x5buy; 0x6buy; 0x51uy; 0xb4uy; 0x71uy; 0xdduy; 0xf7uy; 0x2auy; 0xe4uy; 0xf4uy; 0x72uy; 0x76uy; 0xaduy; 0xc2uy; 0xdduy; 0x64uy; 0x5duy; 0x79uy; 0xb6uy; 0xf5uy; 0x7auy; 0x77uy; 0x20uy; 0x05uy; 0x3duy; 0x30uy; 0x06uy; 0xd4uy; 0x4cuy; 0x0auy; 0x2cuy; 0x98uy; 0x5auy; 0xb9uy; 0xd4uy; 0x98uy; 0xa9uy; 0x3fuy; 0xc6uy; 0x12uy; 0xeauy; 0x3buy; 0x4buy; 0xc5uy; 0x79uy; 0x64uy; 0x63uy; 0x6buy; 0x09uy; 0x54uy; 0x3buy; 0x14uy; 0x27uy; 0xbauy; 0x99uy; 0x80uy; 0xc8uy; 0x72uy; 0xa8uy; 0x12uy; 0x90uy; 0x29uy; 0xbauy; 0x40uy; 0x54uy; 0x97uy; 0x2buy; 0x7buy; 0xfeuy; 0xebuy; 0xcduy; 0x01uy; 0x05uy; 0x44uy; 0x72uy; 0xdbuy; 0x99uy; 0xe4uy; 0x61uy; 0xc9uy; 0x69uy; 0xd6uy; 0xb9uy; 0x28uy; 0xd1uy; 0x05uy; 0x3euy; 0xf9uy; 0x0buy; 0x49uy; 0x0auy; 0x49uy; 0xe9uy; 0x8duy; 0x0euy; 0xa7uy; 0x4auy; 0x0fuy; 0xafuy; 0x32uy; 0xd0uy; 0xe0uy; 0xb2uy; 0x3auy; 0x55uy; 0x58uy; 0xfeuy; 0x5cuy; 0x28uy; 0x70uy; 0x51uy; 0x23uy; 0xb0uy; 0x7buy; 0x6auy; 0x5fuy; 0x1euy; 0xb8uy; 0x17uy; 0xd7uy; 0x94uy; 0x15uy; 0x8fuy; 0xeeuy; 0x20uy; 0xc7uy; 0x42uy; 0x25uy; 0x3euy; 0x9auy; 0x14uy; 0xd7uy; 0x60uy; 0x72uy; 0x39uy; 0x47uy; 0x48uy; 0xa9uy; 0xfeuy; 0xdduy; 0x47uy; 0x0auy; 0xb1uy; 0xe6uy; 0x60uy; 0x28uy; 0x8cuy; 0x11uy; 0x68uy; 0xe1uy; 0xffuy; 0xd7uy; 0xceuy; 0xc8uy; 0xbeuy; 0xb3uy; 0xfeuy; 0x27uy; 0x30uy; 0x09uy; 0x70uy; 0xd7uy; 0xfauy; 0x02uy; 0x33uy; 0x3auy; 0x61uy; 0x2euy; 0xc7uy; 0xffuy; 0xa4uy; 0x2auy; 0xa8uy; 0x6euy; 0xb4uy; 0x79uy; 0x35uy; 0x6duy; 0x4cuy; 0x1euy; 0x38uy; 0xf8uy; 0xeeuy; 0xd4uy; 0x84uy; 0x4euy; 0x6euy; 0x28uy; 0xa7uy; 0xceuy; 0xc8uy; 0xc1uy; 0xcfuy; 0x80uy; 0x05uy; 0xf3uy; 0x04uy; 0xefuy; 0xc8uy; 0x18uy; 0x28uy; 0x2euy; 0x8duy; 0x5euy; 0x0cuy; 0xdfuy; 0xb8uy; 0x5fuy; 0x96uy; 0xe8uy; 0xc6uy; 0x9cuy; 0x2fuy; 0xe5uy; 0xa6uy; 0x44uy; 0xd7uy; 0xe7uy; 0x99uy; 0x44uy; 0x0cuy; 0xecuy; 0xd7uy; 0x05uy; 0x60uy; 0x97uy; 0xbbuy; 0x74uy; 0x77uy; 0x58uy; 0xd5uy; 0xbbuy; 0x48uy; 0xdeuy; 0x5auy; 0xb2uy; 0x54uy; 0x7fuy; 0x0euy; 0x46uy; 0x70uy; 0x6auy; 0x6fuy; 0x78uy; 0xa5uy; 0x08uy; 0x89uy; 0x05uy; 0x4euy; 0x7euy; 0xa0uy; 0x69uy; 0xb4uy; 0x40uy; 0x60uy; 0x55uy; 0x77uy; 0x75uy; 0x9buy; 0x19uy; 0xf2uy; 0xd5uy; 0x13uy; 0x80uy; 0x77uy; 0xf9uy; 0x4buy; 0x3fuy; 0x1euy; 0xeeuy; 0xe6uy; 0x76uy; 0x84uy; 0x7buy; 0x8cuy; 0xe5uy; 0x27uy; 0xa8uy; 0x0auy; 0x91uy; 0x01uy; 0x68uy; 0x71uy; 0x8auy; 0x3fuy; 0x06uy; 0xabuy; 0xf6uy; 0xa9uy; 0xa5uy; 0xe6uy; 0x72uy; 0x92uy; 0xe4uy; 0x67uy; 0xe2uy; 0xa2uy; 0x46uy; 0x35uy; 0x84uy; 0x55uy; 0x7duy; 0xcauy; 0xa8uy; 0x85uy; 0xd0uy; 0xf1uy; 0x3fuy; 0xbeuy; 0xd7uy; 0x34uy; 0x64uy; 0xfcuy; 0xaeuy; 0xe3uy; 0xe4uy; 0x04uy; 0x9fuy; 0x66uy; 0x02uy; 0xb9uy; 0x88uy; 0x10uy; 0xd9uy; 0xc4uy; 0x4cuy; 0x31uy; 0x43uy; 0x7auy; 0x93uy; 0xe2uy; 0x9buy; 0x56uy; 0x43uy; 0x84uy; 0xdcuy; 0xdcuy; 0xdeuy; 0x1duy; 0xa4uy; 0x02uy; 0x0euy; 0xc2uy; 0xefuy; 0xc3uy; 0xf8uy; 0x78uy; 0xd1uy; 0xb2uy; 0x6buy; 0x63uy; 0x18uy; 0xc9uy; 0xa9uy; 0xe5uy; 0x72uy; 0xd8uy; 0xf3uy; 0xb9uy; 0xd1uy; 0x8auy; 0xc7uy; 0x1auy; 0x02uy; 0x27uy; 0x20uy; 0x77uy; 0x10uy; 0xe5uy; 0xc8uy; 0xd4uy; 0x4auy; 0x47uy; 0xe5uy; 0xdfuy; 0x5fuy; 0x01uy; 0xaauy; 0xb0uy; 0xd4uy; 0x10uy; 0xbbuy; 0x69uy; 0xe3uy; 0x36uy; 0xc8uy; 0xe1uy; 0x3duy; 0x43uy; 0xfbuy; 0x86uy; 0xcduy; 0xccuy; 0xbfuy; 0xf4uy; 0x88uy; 0xe0uy; 0x20uy; 0xcauy; 0xb7uy; 0x1buy; 0xf1uy; 0x2fuy; 0x5cuy; 0xeeuy; 0xd4uy; 0xd3uy; 0xa3uy; 0xccuy; 0xa4uy; 0x1euy; 0x1cuy; 0x47uy; 0xfbuy; 0xbfuy; 0xfcuy; 0xa2uy; 0x41uy; 0x55uy; 0x9duy; 0xf6uy; 0x5auy; 0x5euy; 0x65uy; 0x32uy; 0x34uy; 0x7buy; 0x52uy; 0x8duy; 0xd5uy; 0xd0uy; 0x20uy; 0x60uy; 0x03uy; 0xabuy; 0x3fuy; 0x8cuy; 0xd4uy; 0x21uy; 0xeauy; 0x2auy; 0xd9uy; 0xc4uy; 0xd0uy; 0xd3uy; 0x65uy; 0xd8uy; 0x7auy; 0x13uy; 0x28uy; 0x62uy; 0x32uy; 0x4buy; 0x2cuy; 0x87uy; 0x93uy; 0xa8uy; 0xb4uy; 0x52uy; 0x45uy; 0x09uy; 0x44uy; 0xecuy; 0xecuy; 0xc3uy; 0x17uy; 0xdbuy; 0x9auy; 0x4duy; 0x5cuy; 0xa9uy; 0x11uy; 0xd4uy; 0x7duy; 0xafuy; 0x9euy; 0xf1uy; 0x2duy; 0xb2uy; 0x66uy; 0xc5uy; 0x1duy; 0xeduy; 0xb7uy; 0xcduy; 0x0buy; 0x25uy; 0x5euy; 0x30uy; 0x47uy; 0x3fuy; 0x40uy; 0xf4uy; 0xa1uy; 0xa0uy; 0x00uy; 0x94uy; 0x10uy; 0xc5uy; 0x6auy; 0x63uy; 0x1auy; 0xd5uy; 0x88uy; 0x92uy; 0x8euy; 0x82uy; 0x39uy; 0x87uy; 0x3cuy; 0x78uy; 0x65uy; 0x58uy; 0x42uy; 0x75uy; 0x5buy; 0xdduy; 0x77uy; 0x3euy; 0x09uy; 0x4euy; 0x76uy; 0x5buy; 0xe6uy; 0x0euy; 0x4duy; 0x38uy; 0xb2uy; 0xc0uy; 0xb8uy; 0x95uy; 0x01uy; 0x7auy; 0x10uy; 0xe0uy; 0xfbuy; 0x07uy; 0xf2uy; 0xabuy; 0x2duy; 0x8cuy; 0x32uy; 0xeduy; 0x2buy; 0xc0uy; 0x46uy; 0xc2uy; 0xf5uy; 0x38uy; 0x83uy; 0xf0uy; 0x17uy; 0xecuy; 0xc1uy; 0x20uy; 0x6auy; 0x9auy; 0x0buy; 0x00uy; 0xa0uy; 0x98uy; 0x22uy; 0x50uy; 0x23uy; 0xd5uy; 0x80uy; 0x6buy; 0xf6uy; 0x1fuy; 0xc3uy; 0xccuy; 0x97uy; 0xc9uy; 0x24uy; 0x9fuy; 0xf3uy; 0xafuy; 0x43uy; 0x14uy; 0xd5uy; 0xa0uy; ] in assert_norm (List.Tot.length l = 1040); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output9_len: (x:UInt32.t { UInt32.v x = B.length output9 }) = 1040ul let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x35uy; 0x4euy; 0xb5uy; 0x70uy; 0x50uy; 0x42uy; 0x8auy; 0x85uy; 0xf2uy; 0xfbuy; 0xeduy; 0x7buy; 0xd0uy; 0x9euy; 0x97uy; 0xcauy; 0xfauy; 0x98uy; 0x66uy; 0x63uy; 0xeeuy; 0x37uy; 0xccuy; 0x52uy; 0xfeuy; 0xd1uy; 0xdfuy; 0x95uy; 0x15uy; 0x34uy; 0x29uy; 0x38uy; ] 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 nonce10: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfduy; 0x87uy; 0xd4uy; 0xd8uy; 0x62uy; 0xfduy; 0xecuy; 0xaauy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce10_len: (x:UInt32.t { UInt32.v x = B.length nonce10 }) = 12ul let aad10: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) = [@inline_let] let l = [ 0xd6uy; 0x31uy; 0xdauy; 0x5duy; 0x42uy; 0x5euy; 0xd7uy; ] in assert_norm (List.Tot.length l = 7); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad10_len: (x:UInt32.t { UInt32.v x = B.length aad10 }) = 7ul	{ "checked_file": "/", "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.Chacha20Poly1305.fst" }	[ { "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 } ]	{ "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" }	false	b: LowStar.Buffer.buffer FStar.UInt8.t { LowStar.Monotonic.Buffer.length b = 1933 /\ LowStar.Monotonic.Buffer.recallable b /\ LowStar.Monotonic.Buffer.disjoint b Test.Vectors.Chacha20Poly1305.aad10 }	Prims.Tot	[ "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", "LowStar.Monotonic.Buffer.disjoint", "Test.Vectors.Chacha20Poly1305.aad10", "Prims.list", "Prims.Cons", "FStar.UInt8.__uint_to_t", "Prims.Nil", "LowStar.Monotonic.Buffer.recall" ]	[]	false	false	false	false	false	let input10:(b: B.buffer UInt8.t {B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10}) =	B.recall aad10; [@@ inline_let ]let l = [ 0x7auy; 0x57uy; 0xf2uy; 0xc7uy; 0x06uy; 0x3fuy; 0x50uy; 0x7buy; 0x36uy; 0x1auy; 0x66uy; 0x5cuy; 0xb9uy; 0x0euy; 0x5euy; 0x3buy; 0x45uy; 0x60uy; 0xbeuy; 0x9auy; 0x31uy; 0x9fuy; 0xffuy; 0x5duy; 0x66uy; 0x34uy; 0xb4uy; 0xdcuy; 0xfbuy; 0x9duy; 0x8euy; 0xeeuy; 0x6auy; 0x33uy; 0xa4uy; 0x07uy; 0x3cuy; 0xf9uy; 0x4cuy; 0x30uy; 0xa1uy; 0x24uy; 0x52uy; 0xf9uy; 0x50uy; 0x46uy; 0x88uy; 0x20uy; 0x02uy; 0x32uy; 0x3auy; 0x0euy; 0x99uy; 0x63uy; 0xafuy; 0x1fuy; 0x15uy; 0x28uy; 0x2auy; 0x05uy; 0xffuy; 0x57uy; 0x59uy; 0x5euy; 0x18uy; 0xa1uy; 0x1fuy; 0xd0uy; 0x92uy; 0x5cuy; 0x88uy; 0x66uy; 0x1buy; 0x00uy; 0x64uy; 0xa5uy; 0x93uy; 0x8duy; 0x06uy; 0x46uy; 0xb0uy; 0x64uy; 0x8buy; 0x8buy; 0xefuy; 0x99uy; 0x05uy; 0x35uy; 0x85uy; 0xb3uy; 0xf3uy; 0x33uy; 0xbbuy; 0xecuy; 0x66uy; 0xb6uy; 0x3duy; 0x57uy; 0x42uy; 0xe3uy; 0xb4uy; 0xc6uy; 0xaauy; 0xb0uy; 0x41uy; 0x2auy; 0xb9uy; 0x59uy; 0xa9uy; 0xf6uy; 0x3euy; 0x15uy; 0x26uy; 0x12uy; 0x03uy; 0x21uy; 0x4cuy; 0x74uy; 0x43uy; 0x13uy; 0x2auy; 0x03uy; 0x27uy; 0x09uy; 0xb4uy; 0xfbuy; 0xe7uy; 0xb7uy; 0x40uy; 0xffuy; 0x5euy; 0xceuy; 0x48uy; 0x9auy; 0x60uy; 0xe3uy; 0x8buy; 0x80uy; 0x8cuy; 0x38uy; 0x2duy; 0xcbuy; 0x93uy; 0x37uy; 0x74uy; 0x05uy; 0x52uy; 0x6fuy; 0x73uy; 0x3euy; 0xc3uy; 0xbcuy; 0xcauy; 0x72uy; 0x0auy; 0xebuy; 0xf1uy; 0x3buy; 0xa0uy; 0x95uy; 0xdcuy; 0x8auy; 0xc4uy; 0xa9uy; 0xdcuy; 0xcauy; 0x44uy; 0xd8uy; 0x08uy; 0x63uy; 0x6auy; 0x36uy; 0xd3uy; 0x3cuy; 0xb8uy; 0xacuy; 0x46uy; 0x7duy; 0xfduy; 0xaauy; 0xebuy; 0x3euy; 0x0fuy; 0x45uy; 0x8fuy; 0x49uy; 0xdauy; 0x2buy; 0xf2uy; 0x12uy; 0xbduy; 0xafuy; 0x67uy; 0x8auy; 0x63uy; 0x48uy; 0x4buy; 0x55uy; 0x5fuy; 0x6duy; 0x8cuy; 0xb9uy; 0x76uy; 0x34uy; 0x84uy; 0xaeuy; 0xc2uy; 0xfcuy; 0x52uy; 0x64uy; 0x82uy; 0xf7uy; 0xb0uy; 0x06uy; 0xf0uy; 0x45uy; 0x73uy; 0x12uy; 0x50uy; 0x30uy; 0x72uy; 0xeauy; 0x78uy; 0x9auy; 0xa8uy; 0xafuy; 0xb5uy; 0xe3uy; 0xbbuy; 0x77uy; 0x52uy; 0xecuy; 0x59uy; 0x84uy; 0xbfuy; 0x6buy; 0x8fuy; 0xceuy; 0x86uy; 0x5euy; 0x1fuy; 0x23uy; 0xe9uy; 0xfbuy; 0x08uy; 0x86uy; 0xf7uy; 0x10uy; 0xb9uy; 0xf2uy; 0x44uy; 0x96uy; 0x44uy; 0x63uy; 0xa9uy; 0xa8uy; 0x78uy; 0x00uy; 0x23uy; 0xd6uy; 0xc7uy; 0xe7uy; 0x6euy; 0x66uy; 0x4fuy; 0xccuy; 0xeeuy; 0x15uy; 0xb3uy; 0xbduy; 0x1duy; 0xa0uy; 0xe5uy; 0x9cuy; 0x1buy; 0x24uy; 0x2cuy; 0x4duy; 0x3cuy; 0x62uy; 0x35uy; 0x9cuy; 0x88uy; 0x59uy; 0x09uy; 0xdduy; 0x82uy; 0x1buy; 0xcfuy; 0x0auy; 0x83uy; 0x6buy; 0x3fuy; 0xaeuy; 0x03uy; 0xc4uy; 0xb4uy; 0xdduy; 0x7euy; 0x5buy; 0x28uy; 0x76uy; 0x25uy; 0x96uy; 0xd9uy; 0xc9uy; 0x9duy; 0x5fuy; 0x86uy; 0xfauy; 0xf6uy; 0xd7uy; 0xd2uy; 0xe6uy; 0x76uy; 0x1duy; 0x0fuy; 0xa1uy; 0xdcuy; 0x74uy; 0x05uy; 0x1buy; 0x1duy; 0xe0uy; 0xcduy; 0x16uy; 0xb0uy; 0xa8uy; 0x8auy; 0x34uy; 0x7buy; 0x15uy; 0x11uy; 0x77uy; 0xe5uy; 0x7buy; 0x7euy; 0x20uy; 0xf7uy; 0xdauy; 0x38uy; 0xdauy; 0xceuy; 0x70uy; 0xe9uy; 0xf5uy; 0x6cuy; 0xd9uy; 0xbeuy; 0x0cuy; 0x4cuy; 0x95uy; 0x4cuy; 0xc2uy; 0x9buy; 0x34uy; 0x55uy; 0x55uy; 0xe1uy; 0xf3uy; 0x46uy; 0x8euy; 0x48uy; 0x74uy; 0x14uy; 0x4fuy; 0x9duy; 0xc9uy; 0xf5uy; 0xe8uy; 0x1auy; 0xf0uy; 0x11uy; 0x4auy; 0xc1uy; 0x8duy; 0xe0uy; 0x93uy; 0xa0uy; 0xbeuy; 0x09uy; 0x1cuy; 0x2buy; 0x4euy; 0x0fuy; 0xb2uy; 0x87uy; 0x8buy; 0x84uy; 0xfeuy; 0x92uy; 0x32uy; 0x14uy; 0xd7uy; 0x93uy; 0xdfuy; 0xe7uy; 0x44uy; 0xbcuy; 0xc5uy; 0xaeuy; 0x53uy; 0x69uy; 0xd8uy; 0xb3uy; 0x79uy; 0x37uy; 0x80uy; 0xe3uy; 0x17uy; 0x5cuy; 0xecuy; 0x53uy; 0x00uy; 0x9auy; 0xe3uy; 0x8euy; 0xdcuy; 0x38uy; 0xb8uy; 0x66uy; 0xf0uy; 0xd3uy; 0xaduy; 0x1duy; 0x02uy; 0x96uy; 0x86uy; 0x3euy; 0x9duy; 0x3buy; 0x5duy; 0xa5uy; 0x7fuy; 0x21uy; 0x10uy; 0xf1uy; 0x1fuy; 0x13uy; 0x20uy; 0xf9uy; 0x57uy; 0x87uy; 0x20uy; 0xf5uy; 0x5fuy; 0xf1uy; 0x17uy; 0x48uy; 0x0auy; 0x51uy; 0x5auy; 0xcduy; 0x19uy; 0x03uy; 0xa6uy; 0x5auy; 0xd1uy; 0x12uy; 0x97uy; 0xe9uy; 0x48uy; 0xe2uy; 0x1duy; 0x83uy; 0x75uy; 0x50uy; 0xd9uy; 0x75uy; 0x7duy; 0x6auy; 0x82uy; 0xa1uy; 0xf9uy; 0x4euy; 0x54uy; 0x87uy; 0x89uy; 0xc9uy; 0x0cuy; 0xb7uy; 0x5buy; 0x6auy; 0x91uy; 0xc1uy; 0x9cuy; 0xb2uy; 0xa9uy; 0xdcuy; 0x9auy; 0xa4uy; 0x49uy; 0x0auy; 0x6duy; 0x0duy; 0xbbuy; 0xdeuy; 0x86uy; 0x44uy; 0xdduy; 0x5duy; 0x89uy; 0x2buy; 0x96uy; 0x0fuy; 0x23uy; 0x95uy; 0xaduy; 0xccuy; 0xa2uy; 0xb3uy; 0xb9uy; 0x7euy; 0x74uy; 0x38uy; 0xbauy; 0x9fuy; 0x73uy; 0xaeuy; 0x5fuy; 0xf8uy; 0x68uy; 0xa2uy; 0xe0uy; 0xa9uy; 0xceuy; 0xbduy; 0x40uy; 0xd4uy; 0x4cuy; 0x6buy; 0xd2uy; 0x56uy; 0x62uy; 0xb0uy; 0xccuy; 0x63uy; 0x7euy; 0x5buy; 0xd3uy; 0xaeuy; 0xd1uy; 0x75uy; 0xceuy; 0xbbuy; 0xb4uy; 0x5buy; 0xa8uy; 0xf8uy; 0xb4uy; 0xacuy; 0x71uy; 0x75uy; 0xaauy; 0xc9uy; 0x9fuy; 0xbbuy; 0x6cuy; 0xaduy; 0x0fuy; 0x55uy; 0x5duy; 0xe8uy; 0x85uy; 0x7duy; 0xf9uy; 0x21uy; 0x35uy; 0xeauy; 0x92uy; 0x85uy; 0x2buy; 0x00uy; 0xecuy; 0x84uy; 0x90uy; 0x0auy; 0x63uy; 0x96uy; 0xe4uy; 0x6buy; 0xa9uy; 0x77uy; 0xb8uy; 0x91uy; 0xf8uy; 0x46uy; 0x15uy; 0x72uy; 0x63uy; 0x70uy; 0x01uy; 0x40uy; 0xa3uy; 0xa5uy; 0x76uy; 0x62uy; 0x2buy; 0xbfuy; 0xf1uy; 0xe5uy; 0x8duy; 0x9fuy; 0xa3uy; 0xfauy; 0x9buy; 0x03uy; 0xbeuy; 0xfeuy; 0x65uy; 0x6fuy; 0xa2uy; 0x29uy; 0x0duy; 0x54uy; 0xb4uy; 0x71uy; 0xceuy; 0xa9uy; 0xd6uy; 0x3duy; 0x88uy; 0xf9uy; 0xafuy; 0x6buy; 0xa8uy; 0x9euy; 0xf4uy; 0x16uy; 0x96uy; 0x36uy; 0xb9uy; 0x00uy; 0xdcuy; 0x10uy; 0xabuy; 0xb5uy; 0x08uy; 0x31uy; 0x1fuy; 0x00uy; 0xb1uy; 0x3cuy; 0xd9uy; 0x38uy; 0x3euy; 0xc6uy; 0x04uy; 0xa7uy; 0x4euy; 0xe8uy; 0xaeuy; 0xeduy; 0x98uy; 0xc2uy; 0xf7uy; 0xb9uy; 0x00uy; 0x5fuy; 0x8cuy; 0x60uy; 0xd1uy; 0xe5uy; 0x15uy; 0xf7uy; 0xaeuy; 0x1euy; 0x84uy; 0x88uy; 0xd1uy; 0xf6uy; 0xbcuy; 0x3auy; 0x89uy; 0x35uy; 0x22uy; 0x83uy; 0x7cuy; 0xcauy; 0xf0uy; 0x33uy; 0x82uy; 0x4cuy; 0x79uy; 0x3cuy; 0xfduy; 0xb1uy; 0xaeuy; 0x52uy; 0x62uy; 0x55uy; 0xd2uy; 0x41uy; 0x60uy; 0xc6uy; 0xbbuy; 0xfauy; 0x0euy; 0x59uy; 0xd6uy; 0xa8uy; 0xfeuy; 0x5duy; 0xeduy; 0x47uy; 0x3duy; 0xe0uy; 0xeauy; 0x1fuy; 0x6euy; 0x43uy; 0x51uy; 0xecuy; 0x10uy; 0x52uy; 0x56uy; 0x77uy; 0x42uy; 0x6buy; 0x52uy; 0x87uy; 0xd8uy; 0xecuy; 0xe0uy; 0xaauy; 0x76uy; 0xa5uy; 0x84uy; 0x2auy; 0x22uy; 0x24uy; 0xfduy; 0x92uy; 0x40uy; 0x88uy; 0xd5uy; 0x85uy; 0x1cuy; 0x1fuy; 0x6buy; 0x47uy; 0xa0uy; 0xc4uy; 0xe4uy; 0xefuy; 0xf4uy; 0xeauy; 0xd7uy; 0x59uy; 0xacuy; 0x2auy; 0x9euy; 0x8cuy; 0xfauy; 0x1fuy; 0x42uy; 0x08uy; 0xfeuy; 0x4fuy; 0x74uy; 0xa0uy; 0x26uy; 0xf5uy; 0xb3uy; 0x84uy; 0xf6uy; 0x58uy; 0x5fuy; 0x26uy; 0x66uy; 0x3euy; 0xd7uy; 0xe4uy; 0x22uy; 0x91uy; 0x13uy; 0xc8uy; 0xacuy; 0x25uy; 0x96uy; 0x23uy; 0xd8uy; 0x09uy; 0xeauy; 0x45uy; 0x75uy; 0x23uy; 0xb8uy; 0x5fuy; 0xc2uy; 0x90uy; 0x8buy; 0x09uy; 0xc4uy; 0xfcuy; 0x47uy; 0x6cuy; 0x6duy; 0x0auy; 0xefuy; 0x69uy; 0xa4uy; 0x38uy; 0x19uy; 0xcfuy; 0x7duy; 0xf9uy; 0x09uy; 0x73uy; 0x9buy; 0x60uy; 0x5auy; 0xf7uy; 0x37uy; 0xb5uy; 0xfeuy; 0x9fuy; 0xe3uy; 0x2buy; 0x4cuy; 0x0duy; 0x6euy; 0x19uy; 0xf1uy; 0xd6uy; 0xc0uy; 0x70uy; 0xf3uy; 0x9duy; 0x22uy; 0x3cuy; 0xf9uy; 0x49uy; 0xceuy; 0x30uy; 0x8euy; 0x44uy; 0xb5uy; 0x76uy; 0x15uy; 0x8fuy; 0x52uy; 0xfduy; 0xa5uy; 0x04uy; 0xb8uy; 0x55uy; 0x6auy; 0x36uy; 0x59uy; 0x7cuy; 0xc4uy; 0x48uy; 0xb8uy; 0xd7uy; 0xabuy; 0x05uy; 0x66uy; 0xe9uy; 0x5euy; 0x21uy; 0x6fuy; 0x6buy; 0x36uy; 0x29uy; 0xbbuy; 0xe9uy; 0xe3uy; 0xa2uy; 0x9auy; 0xa8uy; 0xcduy; 0x55uy; 0x25uy; 0x11uy; 0xbauy; 0x5auy; 0x58uy; 0xa0uy; 0xdeuy; 0xaeuy; 0x19uy; 0x2auy; 0x48uy; 0x5auy; 0xffuy; 0x36uy; 0xcduy; 0x6duy; 0x16uy; 0x7auy; 0x73uy; 0x38uy; 0x46uy; 0xe5uy; 0x47uy; 0x59uy; 0xc8uy; 0xa2uy; 0xf6uy; 0xe2uy; 0x6cuy; 0x83uy; 0xc5uy; 0x36uy; 0x2cuy; 0x83uy; 0x7duy; 0xb4uy; 0x01uy; 0x05uy; 0x69uy; 0xe7uy; 0xafuy; 0x5cuy; 0xc4uy; 0x64uy; 0x82uy; 0x12uy; 0x21uy; 0xefuy; 0xf7uy; 0xd1uy; 0x7duy; 0xb8uy; 0x8duy; 0x8cuy; 0x98uy; 0x7cuy; 0x5fuy; 0x7duy; 0x92uy; 0x88uy; 0xb9uy; 0x94uy; 0x07uy; 0x9cuy; 0xd8uy; 0xe9uy; 0x9cuy; 0x17uy; 0x38uy; 0xe3uy; 0x57uy; 0x6cuy; 0xe0uy; 0xdcuy; 0xa5uy; 0x92uy; 0x42uy; 0xb3uy; 0xbduy; 0x50uy; 0xa2uy; 0x7euy; 0xb5uy; 0xb1uy; 0x52uy; 0x72uy; 0x03uy; 0x97uy; 0xd8uy; 0xaauy; 0x9auy; 0x1euy; 0x75uy; 0x41uy; 0x11uy; 0xa3uy; 0x4fuy; 0xccuy; 0xd4uy; 0xe3uy; 0x73uy; 0xaduy; 0x96uy; 0xdcuy; 0x47uy; 0x41uy; 0x9fuy; 0xb0uy; 0xbeuy; 0x79uy; 0x91uy; 0xf5uy; 0xb6uy; 0x18uy; 0xfeuy; 0xc2uy; 0x83uy; 0x18uy; 0x7duy; 0x73uy; 0xd9uy; 0x4fuy; 0x83uy; 0x84uy; 0x03uy; 0xb3uy; 0xf0uy; 0x77uy; 0x66uy; 0x3duy; 0x83uy; 0x63uy; 0x2euy; 0x2cuy; 0xf9uy; 0xdduy; 0xa6uy; 0x1fuy; 0x89uy; 0x82uy; 0xb8uy; 0x23uy; 0x42uy; 0xebuy; 0xe2uy; 0xcauy; 0x70uy; 0x82uy; 0x61uy; 0x41uy; 0x0auy; 0x6duy; 0x5fuy; 0x75uy; 0xc5uy; 0xe2uy; 0xc4uy; 0x91uy; 0x18uy; 0x44uy; 0x22uy; 0xfauy; 0x34uy; 0x10uy; 0xf5uy; 0x20uy; 0xdcuy; 0xb7uy; 0xdduy; 0x2auy; 0x20uy; 0x77uy; 0xf5uy; 0xf9uy; 0xceuy; 0xdbuy; 0xa0uy; 0x0auy; 0x52uy; 0x2auy; 0x4euy; 0xdduy; 0xccuy; 0x97uy; 0xdfuy; 0x05uy; 0xe4uy; 0x5euy; 0xb7uy; 0xaauy; 0xf0uy; 0xe2uy; 0x80uy; 0xffuy; 0xbauy; 0x1auy; 0x0fuy; 0xacuy; 0xdfuy; 0x02uy; 0x32uy; 0xe6uy; 0xf7uy; 0xc7uy; 0x17uy; 0x13uy; 0xb7uy; 0xfcuy; 0x98uy; 0x48uy; 0x8cuy; 0x0duy; 0x82uy; 0xc9uy; 0x80uy; 0x7auy; 0xe2uy; 0x0auy; 0xc5uy; 0xb4uy; 0xdeuy; 0x7cuy; 0x3cuy; 0x79uy; 0x81uy; 0x0euy; 0x28uy; 0x65uy; 0x79uy; 0x67uy; 0x82uy; 0x69uy; 0x44uy; 0x66uy; 0x09uy; 0xf7uy; 0x16uy; 0x1auy; 0xf9uy; 0x7duy; 0x80uy; 0xa1uy; 0x79uy; 0x14uy; 0xa9uy; 0xc8uy; 0x20uy; 0xfbuy; 0xa2uy; 0x46uy; 0xbeuy; 0x08uy; 0x35uy; 0x17uy; 0x58uy; 0xc1uy; 0x1auy; 0xdauy; 0x2auy; 0x6buy; 0x2euy; 0x1euy; 0xe6uy; 0x27uy; 0x55uy; 0x7buy; 0x19uy; 0xe2uy; 0xfbuy; 0x64uy; 0xfcuy; 0x5euy; 0x15uy; 0x54uy; 0x3cuy; 0xe7uy; 0xc2uy; 0x11uy; 0x50uy; 0x30uy; 0xb8uy; 0x72uy; 0x03uy; 0x0buy; 0x1auy; 0x9fuy; 0x86uy; 0x27uy; 0x11uy; 0x5cuy; 0x06uy; 0x2buy; 0xbduy; 0x75uy; 0x1auy; 0x0auy; 0xdauy; 0x01uy; 0xfauy; 0x5cuy; 0x4auy; 0xc1uy; 0x80uy; 0x3auy; 0x6euy; 0x30uy; 0xc8uy; 0x2cuy; 0xebuy; 0x56uy; 0xecuy; 0x89uy; 0xfauy; 0x35uy; 0x7buy; 0xb2uy; 0xf0uy; 0x97uy; 0x08uy; 0x86uy; 0x53uy; 0xbeuy; 0xbduy; 0x40uy; 0x41uy; 0x38uy; 0x1cuy; 0xb4uy; 0x8buy; 0x79uy; 0x2euy; 0x18uy; 0x96uy; 0x94uy; 0xdeuy; 0xe8uy; 0xcauy; 0xe5uy; 0x9fuy; 0x92uy; 0x9fuy; 0x15uy; 0x5duy; 0x56uy; 0x60uy; 0x5cuy; 0x09uy; 0xf9uy; 0x16uy; 0xf4uy; 0x17uy; 0x0fuy; 0xf6uy; 0x4cuy; 0xdauy; 0xe6uy; 0x67uy; 0x89uy; 0x9fuy; 0xcauy; 0x6cuy; 0xe7uy; 0x9buy; 0x04uy; 0x62uy; 0x0euy; 0x26uy; 0xa6uy; 0x52uy; 0xbduy; 0x29uy; 0xffuy; 0xc7uy; 0xa4uy; 0x96uy; 0xe6uy; 0x6auy; 0x02uy; 0xa5uy; 0x2euy; 0x7buy; 0xfeuy; 0x97uy; 0x68uy; 0x3euy; 0x2euy; 0x5fuy; 0x3buy; 0x0fuy; 0x36uy; 0xd6uy; 0x98uy; 0x19uy; 0x59uy; 0x48uy; 0xd2uy; 0xc6uy; 0xe1uy; 0x55uy; 0x1auy; 0x6euy; 0xd6uy; 0xeduy; 0x2cuy; 0xbauy; 0xc3uy; 0x9euy; 0x64uy; 0xc9uy; 0x95uy; 0x86uy; 0x35uy; 0x5euy; 0x3euy; 0x88uy; 0x69uy; 0x99uy; 0x4buy; 0xeeuy; 0xbeuy; 0x9auy; 0x99uy; 0xb5uy; 0x6euy; 0x58uy; 0xaeuy; 0xdduy; 0x22uy; 0xdbuy; 0xdduy; 0x6buy; 0xfcuy; 0xafuy; 0x90uy; 0xa3uy; 0x3duy; 0xa4uy; 0xc1uy; 0x15uy; 0x92uy; 0x18uy; 0x8duy; 0xd2uy; 0x4buy; 0x7buy; 0x06uy; 0xd1uy; 0x37uy; 0xb5uy; 0xe2uy; 0x7cuy; 0x2cuy; 0xf0uy; 0x25uy; 0xe4uy; 0x94uy; 0x2auy; 0xbduy; 0xe3uy; 0x82uy; 0x70uy; 0x78uy; 0xa3uy; 0x82uy; 0x10uy; 0x5auy; 0x90uy; 0xd7uy; 0xa4uy; 0xfauy; 0xafuy; 0x1auy; 0x88uy; 0x59uy; 0xdcuy; 0x74uy; 0x12uy; 0xb4uy; 0x8euy; 0xd7uy; 0x19uy; 0x46uy; 0xf4uy; 0x84uy; 0x69uy; 0x9fuy; 0xbbuy; 0x70uy; 0xa8uy; 0x4cuy; 0x52uy; 0x81uy; 0xa9uy; 0xffuy; 0x76uy; 0x1cuy; 0xaeuy; 0xd8uy; 0x11uy; 0x3duy; 0x7fuy; 0x7duy; 0xc5uy; 0x12uy; 0x59uy; 0x28uy; 0x18uy; 0xc2uy; 0xa2uy; 0xb7uy; 0x1cuy; 0x88uy; 0xf8uy; 0xd6uy; 0x1buy; 0xa6uy; 0x7duy; 0x9euy; 0xdeuy; 0x29uy; 0xf8uy; 0xeduy; 0xffuy; 0xebuy; 0x92uy; 0x24uy; 0x4fuy; 0x05uy; 0xaauy; 0xd9uy; 0x49uy; 0xbauy; 0x87uy; 0x59uy; 0x51uy; 0xc9uy; 0x20uy; 0x5cuy; 0x9buy; 0x74uy; 0xcfuy; 0x03uy; 0xd9uy; 0x2duy; 0x34uy; 0xc7uy; 0x5buy; 0xa5uy; 0x40uy; 0xb2uy; 0x99uy; 0xf5uy; 0xcbuy; 0xb4uy; 0xf6uy; 0xb7uy; 0x72uy; 0x4auy; 0xd6uy; 0xbduy; 0xb0uy; 0xf3uy; 0x93uy; 0xe0uy; 0x1buy; 0xa8uy; 0x04uy; 0x1euy; 0x35uy; 0xd4uy; 0x80uy; 0x20uy; 0xf4uy; 0x9cuy; 0x31uy; 0x6buy; 0x45uy; 0xb9uy; 0x15uy; 0xb0uy; 0x5euy; 0xdduy; 0x0auy; 0x33uy; 0x9cuy; 0x83uy; 0xcduy; 0x58uy; 0x89uy; 0x50uy; 0x56uy; 0xbbuy; 0x81uy; 0x00uy; 0x91uy; 0x32uy; 0xf3uy; 0x1buy; 0x3euy; 0xcfuy; 0x45uy; 0xe1uy; 0xf9uy; 0xe1uy; 0x2cuy; 0x26uy; 0x78uy; 0x93uy; 0x9auy; 0x60uy; 0x46uy; 0xc9uy; 0xb5uy; 0x5euy; 0x6auy; 0x28uy; 0x92uy; 0x87uy; 0x3fuy; 0x63uy; 0x7buy; 0xdbuy; 0xf7uy; 0xd0uy; 0x13uy; 0x9duy; 0x32uy; 0x40uy; 0x5euy; 0xcfuy; 0xfbuy; 0x79uy; 0x68uy; 0x47uy; 0x4cuy; 0xfduy; 0x01uy; 0x17uy; 0xe6uy; 0x97uy; 0x93uy; 0x78uy; 0xbbuy; 0xa6uy; 0x27uy; 0xa3uy; 0xe8uy; 0x1auy; 0xe8uy; 0x94uy; 0x55uy; 0x7duy; 0x08uy; 0xe5uy; 0xdcuy; 0x66uy; 0xa3uy; 0x69uy; 0xc8uy; 0xcauy; 0xc5uy; 0xa1uy; 0x84uy; 0x55uy; 0xdeuy; 0x08uy; 0x91uy; 0x16uy; 0x3auy; 0x0cuy; 0x86uy; 0xabuy; 0x27uy; 0x2buy; 0x64uy; 0x34uy; 0x02uy; 0x6cuy; 0x76uy; 0x8buy; 0xc6uy; 0xafuy; 0xccuy; 0xe1uy; 0xd6uy; 0x8cuy; 0x2auy; 0x18uy; 0x3duy; 0xa6uy; 0x1buy; 0x37uy; 0x75uy; 0x45uy; 0x73uy; 0xc2uy; 0x75uy; 0xd7uy; 0x53uy; 0x78uy; 0x3auy; 0xd6uy; 0xe8uy; 0x29uy; 0xd2uy; 0x4auy; 0xa8uy; 0x1euy; 0x82uy; 0xf6uy; 0xb6uy; 0x81uy; 0xdeuy; 0x21uy; 0xeduy; 0x2buy; 0x56uy; 0xbbuy; 0xf2uy; 0xd0uy; 0x57uy; 0xc1uy; 0x7cuy; 0xd2uy; 0x6auy; 0xd2uy; 0x56uy; 0xf5uy; 0x13uy; 0x5fuy; 0x1cuy; 0x6auy; 0x0buy; 0x74uy; 0xfbuy; 0xe9uy; 0xfeuy; 0x9euy; 0xeauy; 0x95uy; 0xb2uy; 0x46uy; 0xabuy; 0x0auy; 0xfcuy; 0xfduy; 0xf3uy; 0xbbuy; 0x04uy; 0x2buy; 0x76uy; 0x1buy; 0xa4uy; 0x74uy; 0xb0uy; 0xc1uy; 0x78uy; 0xc3uy; 0x69uy; 0xe2uy; 0xb0uy; 0x01uy; 0xe1uy; 0xdeuy; 0x32uy; 0x4cuy; 0x8duy; 0x1auy; 0xb3uy; 0x38uy; 0x08uy; 0xd5uy; 0xfcuy; 0x1fuy; 0xdcuy; 0x0euy; 0x2cuy; 0x9cuy; 0xb1uy; 0xa1uy; 0x63uy; 0x17uy; 0x22uy; 0xf5uy; 0x6cuy; 0x93uy; 0x70uy; 0x74uy; 0x00uy; 0xf8uy; 0x39uy; 0x01uy; 0x94uy; 0xd1uy; 0x32uy; 0x23uy; 0x56uy; 0x5duy; 0xa6uy; 0x02uy; 0x76uy; 0x76uy; 0x93uy; 0xceuy; 0x2fuy; 0x19uy; 0xe9uy; 0x17uy; 0x52uy; 0xaeuy; 0x6euy; 0x2cuy; 0x6duy; 0x61uy; 0x7fuy; 0x3buy; 0xaauy; 0xe0uy; 0x52uy; 0x85uy; 0xc5uy; 0x65uy; 0xc1uy; 0xbbuy; 0x8euy; 0x5buy; 0x21uy; 0xd5uy; 0xc9uy; 0x78uy; 0x83uy; 0x07uy; 0x97uy; 0x4cuy; 0x62uy; 0x61uy; 0x41uy; 0xd4uy; 0xfcuy; 0xc9uy; 0x39uy; 0xe3uy; 0x9buy; 0xd0uy; 0xccuy; 0x75uy; 0xc4uy; 0x97uy; 0xe6uy; 0xdduy; 0x2auy; 0x5fuy; 0xa6uy; 0xe8uy; 0x59uy; 0x6cuy; 0x98uy; 0xb9uy; 0x02uy; 0xe2uy; 0xa2uy; 0xd6uy; 0x68uy; 0xeeuy; 0x3buy; 0x1duy; 0xe3uy; 0x4duy; 0x5buy; 0x30uy; 0xefuy; 0x03uy; 0xf2uy; 0xebuy; 0x18uy; 0x57uy; 0x36uy; 0xe8uy; 0xa1uy; 0xf4uy; 0x47uy; 0xfbuy; 0xcbuy; 0x8fuy; 0xcbuy; 0xc8uy; 0xf3uy; 0x4fuy; 0x74uy; 0x9duy; 0x9duy; 0xb1uy; 0x8duy; 0x14uy; 0x44uy; 0xd9uy; 0x19uy; 0xb4uy; 0x54uy; 0x4fuy; 0x75uy; 0x19uy; 0x09uy; 0xa0uy; 0x75uy; 0xbcuy; 0x3buy; 0x82uy; 0xc6uy; 0x3fuy; 0xb8uy; 0x83uy; 0x19uy; 0x6euy; 0xd6uy; 0x37uy; 0xfeuy; 0x6euy; 0x8auy; 0x4euy; 0xe0uy; 0x4auy; 0xabuy; 0x7buy; 0xc8uy; 0xb4uy; 0x1duy; 0xf4uy; 0xeduy; 0x27uy; 0x03uy; 0x65uy; 0xa2uy; 0xa1uy; 0xaeuy; 0x11uy; 0xe7uy; 0x98uy; 0x78uy; 0x48uy; 0x91uy; 0xd2uy; 0xd2uy; 0xd4uy; 0x23uy; 0x78uy; 0x50uy; 0xb1uy; 0x5buy; 0x85uy; 0x10uy; 0x8duy; 0xcauy; 0x5fuy; 0x0fuy; 0x71uy; 0xaeuy; 0x72uy; 0x9auy; 0xf6uy; 0x25uy; 0x19uy; 0x60uy; 0x06uy; 0xf7uy; 0x10uy; 0x34uy; 0x18uy; 0x0duy; 0xc9uy; 0x9fuy; 0x7buy; 0x0cuy; 0x9buy; 0x8fuy; 0x91uy; 0x1buy; 0x9fuy; 0xcduy; 0x10uy; 0xeeuy; 0x75uy; 0xf9uy; 0x97uy; 0x66uy; 0xfcuy; 0x4duy; 0x33uy; 0x6euy; 0x28uy; 0x2buy; 0x92uy; 0x85uy; 0x4fuy; 0xabuy; 0x43uy; 0x8duy; 0x8fuy; 0x7duy; 0x86uy; 0xa7uy; 0xc7uy; 0xd8uy; 0xd3uy; 0x0buy; 0x8buy; 0x57uy; 0xb6uy; 0x1duy; 0x95uy; 0x0duy; 0xe9uy; 0xbcuy; 0xd9uy; 0x03uy; 0xd9uy; 0x10uy; 0x19uy; 0xc3uy; 0x46uy; 0x63uy; 0x55uy; 0x87uy; 0x61uy; 0x79uy; 0x6cuy; 0x95uy; 0x0euy; 0x9cuy; 0xdduy; 0xcauy; 0xc3uy; 0xf3uy; 0x64uy; 0xf0uy; 0x7duy; 0x76uy; 0xb7uy; 0x53uy; 0x67uy; 0x2buy; 0x1euy; 0x44uy; 0x56uy; 0x81uy; 0xeauy; 0x8fuy; 0x5cuy; 0x42uy; 0x16uy; 0xb8uy; 0x28uy; 0xebuy; 0x1buy; 0x61uy; 0x10uy; 0x1euy; 0xbfuy; 0xecuy; 0xa8uy ] in assert_norm (List.Tot.length l = 1933); B.gcmalloc_of_list HyperStack.root l	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_vldata_gen	val validate_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (f': (x: bounded_integer sz -> Tot (y: bool{y == f x}))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p))	val validate_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (f': (x: bounded_integer sz -> Tot (y: bool{y == f x}))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p))	let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) ()	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 40, "start_col": 0, "start_line": 23 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	sz: LowParse.Spec.BoundedInt.integer_size -> f: (x: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> f': (x: LowParse.Spec.BoundedInt.bounded_integer sz -> y: Prims.bool{y == f x}) -> v: LowParse.Low.Base.validator p -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_vldata_gen sz f p)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "Prims.eq2", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Low.Base.validator", "LowParse.Low.Combinators.validate_filter_and_then", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.parse_bounded_integer", "LowParse.Low.BoundedInt.validate_bounded_integer", "LowParse.Low.BoundedInt.read_bounded_integer", "LowParse.Spec.VLData.parse_vldata_payload_kind", "LowParse.Spec.VLData.parse_vldata_payload", "LowParse.Low.VLData.validate_vldata_payload", "Prims.unit", "LowParse.Spec.VLData.parse_vldata_gen_eq_def", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen" ]	[]	false	false	false	false	false	let validate_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (f': (x: bounded_integer sz -> Tot (y: bool{y == f x}))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) =	parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) ()	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_vldata_payload	val validate_vldata_payload (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz {f i == true}) : Tot (validator (parse_vldata_payload sz f p i))	val validate_vldata_payload (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz {f i == true}) : Tot (validator (parse_vldata_payload sz f p i))	let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) ()	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 85, "end_line": 20, "start_col": 0, "start_line": 11 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	sz: LowParse.Spec.BoundedInt.integer_size -> f: (x: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> v: LowParse.Low.Base.validator p -> i: LowParse.Spec.BoundedInt.bounded_integer sz {f i == true} -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_vldata_payload sz f p i)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Low.Base.validator", "Prims.eq2", "LowParse.Low.Combinators.validate_weaken", "LowParse.Spec.VLData.parse_vldata_payload_kind", "LowParse.Spec.FLData.parse_fldata_kind", "FStar.UInt32.v", "LowParse.Spec.FLData.parse_fldata", "LowParse.Low.FLData.validate_fldata", "LowParse.Spec.VLData.parse_vldata_payload" ]	[]	false	false	false	false	false	let validate_vldata_payload (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz {f i == true}) : Tot (validator (parse_vldata_payload sz f p i)) =	validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) ()	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.jump_vldata_gen	val jump_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p))	val jump_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p))	let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos)	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 78, "end_line": 91, "start_col": 0, "start_line": 81 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	sz: LowParse.Spec.BoundedInt.integer_size -> f: (x: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> p: LowParse.Spec.Base.parser k t -> LowParse.Low.Base.jumper (LowParse.Spec.VLData.parse_vldata_gen sz f p)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Low.BoundedInt.read_bounded_integer", "Prims.unit", "LowParse.Low.VLData.valid_vldata_gen_elim", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.Base.jumper", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen" ]	[]	false	false	false	false	false	let jump_vldata_gen (sz: integer_size) (f: (x: bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) =	fun #rrel #rel input pos -> let h = HST.get () in [@@ inline_let ]let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` ((U32.uint_to_t sz) `U32.add` (read_bounded_integer sz input pos))	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.jump_bounded_vldata	val jump_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata min max p))	val jump_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata min max p))	let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 46, "end_line": 165, "start_col": 0, "start_line": 153 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat -> p: LowParse.Spec.Base.parser k t -> u128: u129: Prims.unit{min <= max /\ max > 0 /\ max < 4294967296} -> LowParse.Low.Base.jumper (LowParse.Spec.VLData.parse_bounded_vldata min max p)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "Prims.unit", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Low.VLData.jump_bounded_vldata'", "LowParse.Spec.BoundedInt.log256'", "LowParse.Low.Base.jumper", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata" ]	[]	false	false	false	false	false	let jump_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata min max p)) =	jump_bounded_vldata' min max (log256' max) p	false
Hacl.Impl.SHA2.Core.fst	Hacl.Impl.SHA2.Core.load_last4	val load_last4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> load_last_t a m	val load_last4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> load_last_t a m	let load_last4 #a #m totlen_buf len b fin last = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 b in let last0 = sub last 0ul (2ul ! HD.block_len a) in let last1 = sub last (2ul ! HD.block_len a) (2ul ! HD.block_len a) in let last2 = sub last (4ul ! HD.block_len a) (2ul ! HD.block_len a) in let last3 = sub last (6ul ! HD.block_len a) (2ul ! HD.block_len a) in let h1 = ST.get() in assert (disjoint last0 last1); LSeq.eq_intro (as_seq h1 last0) (LSeq.create (2 block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last1) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last2) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last3) (LSeq.create (2 * block_length a) (u8 0)); let (l00,l01) = load_last_blocks #a totlen_buf len b0 fin last0 in let (l10,l11) = load_last_blocks #a totlen_buf len b1 fin last1 in let (l20,l21) = load_last_blocks #a totlen_buf len b2 fin last2 in let (l30,l31) = load_last_blocks #a totlen_buf len b3 fin last3 in let mb0:multibuf (lanes a m) (HD.block_len a) = ntup4 (l00, (l10, (l20, l30))) in let mb1:multibuf (lanes a m) (HD.block_len a) = ntup4 (l01, (l11, (l21, l31))) in let h1 = ST.get() in assert ((as_seq h1 l00, as_seq h1 l01) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b0)); assert ((as_seq h1 l10, as_seq h1 l11) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b1)); assert ((as_seq h1 l20, as_seq h1 l21) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b2)); assert ((as_seq h1 l30, as_seq h1 l31) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b3)); NTup.eq_intro (as_seq_multi h1 mb0) (ntup4 (as_seq h1 l00, (as_seq h1 l10, (as_seq h1 l20, (as_seq h1 l30))))); NTup.eq_intro (as_seq_multi h1 mb1) (ntup4 (as_seq h1 l01, (as_seq h1 l11, (as_seq h1 l21, (as_seq h1 l31))))); assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3) h0 h1); assert (modifies (loc last) h0 h1); assert (live_multi h1 mb0); assert (live_multi h1 mb1); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (mb0, mb1)	{ "file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 12, "end_line": 474, "start_col": 0, "start_line": 439 }	module Hacl.Impl.SHA2.Core open FStar.Mul open FStar.HyperStack open FStar.HyperStack.All open Lib.IntTypes open Lib.NTuple open Lib.Buffer open Lib.IntVector open Lib.MultiBuffer open Spec.Hash.Definitions //open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq open Hacl.Spec.SHA2.Vec module ST = FStar.HyperStack.ST module NTup = Lib.NTuple module SpecVec = Hacl.Spec.SHA2.Vec module VecTranspose = Lib.IntVector.Transpose module LSeq = Lib.Sequence module HD = Hacl.Hash.Definitions (* Force ordering in dependency analysis so that monomorphizations are inserted into the Types module first. ) let _ = Hacl.Impl.SHA2.Types.uint8_8p #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" unfold let state_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 8ul unfold let block_t (a:sha2_alg) = lbuffer uint8 (HD.block_len a) inline_for_extraction noextract let ws_t (a:sha2_alg) (m:m_spec) = lbuffer (element_t a m) 16ul inline_for_extraction noextract val set_wsi: #a:sha2_alg -> #m:m_spec -> ws:ws_t a m -> i:size_t{v i < 16} -> b:lbuffer uint8 (HD.block_len a) -> bi:size_t{v bi < 16 / (lanes a m)} -> Stack unit (requires fun h -> live h b /\ live h ws /\ disjoint b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == LSeq.upd (as_seq h0 ws) (v i) (SpecVec.load_elementi #a #m (as_seq h0 b) (v bi))) let set_wsi #a #m ws i b bi = [@inline_let] let l = lanes a m in ws.(i) <- vec_load_be (word_t a) l (sub b (bi ! size l ! HD.word_len a) (size l ! HD.word_len a)) noextract let load_blocks_spec1 (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : ws_spec a m = let b = b.(\|0\|) in let ws0 = SpecVec.load_elementi b 0 in let ws1 = SpecVec.load_elementi b 1 in let ws2 = SpecVec.load_elementi b 2 in let ws3 = SpecVec.load_elementi b 3 in let ws4 = SpecVec.load_elementi b 4 in let ws5 = SpecVec.load_elementi b 5 in let ws6 = SpecVec.load_elementi b 6 in let ws7 = SpecVec.load_elementi b 7 in let ws8 = SpecVec.load_elementi b 8 in let ws9 = SpecVec.load_elementi b 9 in let ws10 = SpecVec.load_elementi b 10 in let ws11 = SpecVec.load_elementi b 11 in let ws12 = SpecVec.load_elementi b 12 in let ws13 = SpecVec.load_elementi b 13 in let ws14 = SpecVec.load_elementi b 14 in let ws15 = SpecVec.load_elementi b 15 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec1 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec1 b) #push-options "--z3rlimit 100" inline_for_extraction noextract val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) let load_blocks1 #a #m ib ws = let h0 = ST.get() in let b = ib.(\|0\|) in set_wsi ws 0ul b 0ul; set_wsi ws 1ul b 1ul; set_wsi ws 2ul b 2ul; set_wsi ws 3ul b 3ul; set_wsi ws 4ul b 4ul; set_wsi ws 5ul b 5ul; set_wsi ws 6ul b 6ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b 7ul; set_wsi ws 8ul b 8ul; set_wsi ws 9ul b 9ul; set_wsi ws 10ul b 10ul; set_wsi ws 11ul b 11ul; set_wsi ws 12ul b 12ul; set_wsi ws 13ul b 13ul; set_wsi ws 14ul b 14ul; set_wsi ws 15ul b 15ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib)); load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)) #pop-options noextract let load_blocks_spec4 (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b0 1 in let ws5 = SpecVec.load_elementi b1 1 in let ws6 = SpecVec.load_elementi b2 1 in let ws7 = SpecVec.load_elementi b3 1 in let ws8 = SpecVec.load_elementi b0 2 in let ws9 = SpecVec.load_elementi b1 2 in let ws10 = SpecVec.load_elementi b2 2 in let ws11 = SpecVec.load_elementi b3 2 in let ws12 = SpecVec.load_elementi b0 3 in let ws13 = SpecVec.load_elementi b1 3 in let ws14 = SpecVec.load_elementi b2 3 in let ws15 = SpecVec.load_elementi b3 3 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec4_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec4 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec4 b) inline_for_extraction noextract val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) #push-options "--z3rlimit 150" let load_blocks4 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,b3))) = NTup.tup4 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b0 1ul; set_wsi ws 5ul b1 1ul; set_wsi ws 6ul b2 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b3 1ul; set_wsi ws 8ul b0 2ul; set_wsi ws 9ul b1 2ul; set_wsi ws 10ul b2 2ul; set_wsi ws 11ul b3 2ul; set_wsi ws 12ul b0 3ul; set_wsi ws 13ul b1 3ul; set_wsi ws 14ul b2 3ul; set_wsi ws 15ul b3 3ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec4 (as_seq_multi h0 ib)); load_blocks_spec4_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec4 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); () #pop-options noextract let load_blocks_spec8 (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : ws_spec a m = let b0 = b.(\|0\|) in let b1 = b.(\|1\|) in let b2 = b.(\|2\|) in let b3 = b.(\|3\|) in let b4 = b.(\|4\|) in let b5 = b.(\|5\|) in let b6 = b.(\|6\|) in let b7 = b.(\|7\|) in let ws0 = SpecVec.load_elementi b0 0 in let ws1 = SpecVec.load_elementi b1 0 in let ws2 = SpecVec.load_elementi b2 0 in let ws3 = SpecVec.load_elementi b3 0 in let ws4 = SpecVec.load_elementi b4 0 in let ws5 = SpecVec.load_elementi b5 0 in let ws6 = SpecVec.load_elementi b6 0 in let ws7 = SpecVec.load_elementi b7 0 in let ws8 = SpecVec.load_elementi b0 1 in let ws9 = SpecVec.load_elementi b1 1 in let ws10 = SpecVec.load_elementi b2 1 in let ws11 = SpecVec.load_elementi b3 1 in let ws12 = SpecVec.load_elementi b4 1 in let ws13 = SpecVec.load_elementi b5 1 in let ws14 = SpecVec.load_elementi b6 1 in let ws15 = SpecVec.load_elementi b7 1 in LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 noextract let load_blocks_spec8_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 8}) (b:multiblock_spec a m) : Lemma (SpecVec.load_blocks b == load_blocks_spec8 b) = LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec8 b) inline_for_extraction noextract val load_blocks8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) #push-options "--z3rlimit 150" let load_blocks8 #a #m ib ws = let h0 = ST.get() in let (b0,(b1,(b2,(b3,(b4,(b5,(b6,b7))))))) = NTup.tup8 ib in set_wsi ws 0ul b0 0ul; set_wsi ws 1ul b1 0ul; set_wsi ws 2ul b2 0ul; set_wsi ws 3ul b3 0ul; set_wsi ws 4ul b4 0ul; set_wsi ws 5ul b5 0ul; set_wsi ws 6ul b6 0ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); set_wsi ws 7ul b7 0ul; set_wsi ws 8ul b0 1ul; set_wsi ws 9ul b1 1ul; set_wsi ws 10ul b2 1ul; set_wsi ws 11ul b3 1ul; set_wsi ws 12ul b4 1ul; set_wsi ws 13ul b5 1ul; set_wsi ws 14ul b6 1ul; set_wsi ws 15ul b7 1ul; let h1 = ST.get() in assert (modifies (loc ws) h0 h1); LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec8 (as_seq_multi h0 ib)); load_blocks_spec8_lemma #a #m (as_seq_multi h0 ib); assert (as_seq h1 ws == load_blocks_spec8 (as_seq_multi h0 ib)); assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib)); () #pop-options inline_for_extraction noextract val load_blocks: #a:sha2_alg -> #m:m_spec{is_supported a m} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) let load_blocks #a #m b ws = match lanes a m with \| 1 -> load_blocks1 b ws \| 4 -> load_blocks4 b ws \| 8 -> load_blocks8 b ws inline_for_extraction noextract val transpose_ws4: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws4 #a #m ws = let (ws0,ws1,ws2,ws3) = VecTranspose.transpose4x4 (ws.(0ul),ws.(1ul),ws.(2ul),ws.(3ul)) in let (ws4,ws5,ws6,ws7) = VecTranspose.transpose4x4 (ws.(4ul),ws.(5ul),ws.(6ul),ws.(7ul)) in let (ws8,ws9,ws10,ws11) = VecTranspose.transpose4x4 (ws.(8ul),ws.(9ul),ws.(10ul),ws.(11ul)) in let (ws12,ws13,ws14,ws15) = VecTranspose.transpose4x4 (ws.(12ul),ws.(13ul),ws.(14ul),ws.(15ul)) in create16 ws ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 inline_for_extraction noextract val transpose_ws8: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws8 #a #m ws = let (ws0,ws1,ws2,ws3,ws4,ws5,ws6,ws7) = VecTranspose.transpose8x8 (ws.(0ul),ws.(1ul),ws.(2ul),ws.(3ul),ws.(4ul),ws.(5ul),ws.(6ul),ws.(7ul)) in let (ws8,ws9,ws10,ws11,ws12,ws13,ws14,ws15) = VecTranspose.transpose8x8 (ws.(8ul),ws.(9ul),ws.(10ul),ws.(11ul),ws.(12ul),ws.(13ul),ws.(14ul),ws.(15ul)) in create16 ws ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7 ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15 inline_for_extraction noextract val transpose_ws: #a:sha2_alg -> #m:m_spec{is_supported a m} -> ws:ws_t a m -> Stack unit (requires fun h -> live h ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.transpose_ws (as_seq h0 ws)) let transpose_ws #a #m ws = match lanes a m with \| 1 -> () \| 4 -> transpose_ws4 ws \| 8 -> transpose_ws8 ws inline_for_extraction noextract val load_ws: #a:sha2_alg -> #m:m_spec{is_supported a m} -> b:multibuf (lanes a m) (HD.block_len a) -> ws:ws_t a m -> Stack unit (requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws) (ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\ as_seq h1 ws == SpecVec.load_ws #a #m (as_seq_multi h0 b)) let load_ws #a #m b ws = load_blocks b ws; transpose_ws ws inline_for_extraction noextract let padded_blocks (a:sha2_alg) (len:size_t{v len <= block_length a}) : n:size_t{v n == SpecVec.padded_blocks a (v len)} = if (len +! len_len a +! 1ul <=. HD.block_len a) then 1ul else 2ul inline_for_extraction noextract val load_last_blocks: #a:sha2_alg -> totlen_buf:lbuffer uint8 (len_len a) -> len:size_t{v len <= block_length a} -> b:lbuffer uint8 len -> fin:size_t{v fin == block_length a \/ v fin == 2 * block_length a} -> last:lbuffer uint8 (2ul ! HD.block_len a) -> Stack (lbuffer uint8 (HD.block_len a) & lbuffer uint8 (HD.block_len a)) (requires fun h -> live h totlen_buf /\ live h b /\ live h last /\ disjoint b last /\ disjoint last totlen_buf /\ as_seq h last == LSeq.create (2 block_length a) (u8 0)) (ensures (fun h0 (l0,l1) h1 -> modifies (loc last) h0 h1 /\ live h1 l0 /\ live h1 l1 /\ (forall a l (r:lbuffer a l). disjoint last r ==> (disjoint l0 r /\ disjoint l1 r)) /\ (as_seq h1 l0, as_seq h1 l1) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b))) #push-options "--z3rlimit 200" let load_last_blocks #a totlen_buf len b fin last = let h0 = ST.get() in update_sub last 0ul len b; last.(len) <- u8 0x80; update_sub last (fin -. len_len a) (len_len a) totlen_buf; let last0 : lbuffer uint8 (HD.block_len a) = sub last 0ul (HD.block_len a) in let last1 : lbuffer uint8 (HD.block_len a) = sub last (HD.block_len a) (HD.block_len a) in let h1 = ST.get() in assert (modifies (loc last) h0 h1); (last0,last1) #pop-options noextract let preserves_sub_disjoint_multi #lanes #len #len' (b:lbuffer uint8 len) (r:multibuf lanes len') = (forall a l (x:lbuffer a l). disjoint b x ==> disjoint_multi r x) inline_for_extraction noextract let load_last_t (a:sha2_alg) (m:m_spec{is_supported a m}) = totlen_buf:lbuffer uint8 (len_len a) -> len:size_t{v len <= block_length a} -> b:multibuf (lanes a m) len -> fin:size_t{v fin == block_length a \/ v fin == 2 * block_length a} -> last:lbuffer uint8 (size (lanes a m) ! 2ul ! HD.block_len a) -> Stack (multibuf (lanes a m) (HD.block_len a) & multibuf (lanes a m) (HD.block_len a)) (requires fun h -> live h totlen_buf /\ live_multi h b /\ live h last /\ disjoint_multi b last /\ disjoint last totlen_buf /\ as_seq h last == LSeq.create (lanes a m * 2 * block_length a) (u8 0)) (ensures fun h0 (l0,l1) h1 -> modifies (loc last) h0 h1 /\ live_multi h1 l0 /\ live_multi h1 l1 /\ preserves_sub_disjoint_multi last l0 /\ preserves_sub_disjoint_multi last l1 /\ (as_seq_multi h1 l0, as_seq_multi h1 l1) == SpecVec.load_last #a #m (as_seq h0 totlen_buf) (v fin) (v len) (as_seq_multi h0 b)) inline_for_extraction noextract val load_last1: #a:sha2_alg -> #m:m_spec{lanes a m = 1} -> load_last_t a m #push-options "--z3rlimit 250" let load_last1 #a #m totlen_buf len b fin last = let h0 = ST.get() in let b0 = b.(\|0\|) in let (l0,l1) = load_last_blocks #a totlen_buf len b0 fin last in let lb0 : multibuf (lanes a m) (HD.block_len a) = ntup1 l0 in let lb1 : multibuf (lanes a m) (HD.block_len a) = ntup1 l1 in let h1 = ST.get() in assert (modifies (loc last) h0 h1); NTup.eq_intro (as_seq_multi h0 b) (ntup1 (as_seq h0 b0)); NTup.eq_intro (as_seq_multi h1 lb0) (ntup1 (as_seq h1 l0)); NTup.eq_intro (as_seq_multi h1 lb1) (ntup1 (as_seq h1 l1)); assert ((as_seq_multi h1 lb0, as_seq_multi h1 lb1) == SpecVec.load_last1 #a #m (as_seq h0 totlen_buf) (v fin) (v len) (as_seq_multi h0 b)); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (lb0,lb1) #pop-options inline_for_extraction noextract val load_last4: #a:sha2_alg -> #m:m_spec{lanes a m = 4} -> load_last_t a m	{ "checked_file": "/", "dependencies": [ "Spec.Hash.Definitions.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.NTuple.fsti.checked", "Lib.MultiBuffer.fst.checked", "Lib.IntVector.Transpose.fsti.checked", "Lib.IntVector.Serialize.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Lib.Buffer.fsti.checked", "Hacl.Spec.SHA2.Vec.fst.checked", "Hacl.Impl.SHA2.Types.fst.checked", "Hacl.Hash.Definitions.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.All.fst.checked", "FStar.HyperStack.fst.checked" ], "interface_file": false, "source_file": "Hacl.Impl.SHA2.Core.fst" }	[ { "abbrev": true, "full_module": "Hacl.Hash.Definitions", "short_module": "HD" }, { "abbrev": true, "full_module": "Lib.Sequence", "short_module": "LSeq" }, { "abbrev": true, "full_module": "Lib.IntVector.Transpose", "short_module": "VecTranspose" }, { "abbrev": true, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": "SpecVec" }, { "abbrev": true, "full_module": "Lib.NTuple", "short_module": "NTup" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "ST" }, { "abbrev": false, "full_module": "Hacl.Spec.SHA2.Vec", "short_module": null }, { "abbrev": false, "full_module": "Spec.Hash.Definitions", "short_module": null }, { "abbrev": false, "full_module": "Lib.MultiBuffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.Buffer", "short_module": null }, { "abbrev": false, "full_module": "Lib.NTuple", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack.All", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Impl.SHA2", "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 } ]	{ "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": 350, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	Hacl.Impl.SHA2.Core.load_last_t a m	Prims.Tot	[ "total" ]	[]	[ "Spec.Hash.Definitions.sha2_alg", "Hacl.Spec.SHA2.Vec.m_spec", "Prims.b2t", "Prims.op_Equality", "Prims.int", "Hacl.Spec.SHA2.Vec.lanes", "Lib.Buffer.lbuffer", "Lib.IntTypes.uint8", "Spec.Hash.Definitions.len_len", "Lib.IntTypes.size_t", "Prims.op_LessThanOrEqual", "Lib.IntTypes.v", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "Spec.Hash.Definitions.block_length", "Lib.MultiBuffer.multibuf", "Prims.l_or", "Prims.eq2", "Lib.IntTypes.range", "Prims.op_disEquality", "FStar.Mul.op_Star", "Lib.IntTypes.op_Star_Bang", "Lib.IntTypes.size", "FStar.UInt32.__uint_to_t", "Hacl.Hash.Definitions.block_len", "FStar.Pervasives.Native.Mktuple2", "Prims.unit", "FStar.Pervasives.reveal_opaque", "Lib.Sequence.lseq", "Spec.Hash.Definitions.len_length", "Prims.nat", "Prims.op_GreaterThanOrEqual", "Hacl.Spec.SHA2.Vec.multiseq", "FStar.Pervasives.Native.tuple2", "Hacl.Spec.SHA2.Vec.load_last", "Prims._assert", "Lib.MultiBuffer.live_multi", "Lib.Buffer.modifies", "Lib.Buffer.loc", "Lib.Buffer.MUT", "Lib.Buffer.op_Bar_Plus_Bar", "Lib.NTuple.eq_intro", "FStar.Seq.Properties.lseq", "Lib.MultiBuffer.as_seq_multi", "Lib.NTuple.ntup4", "Lib.Buffer.as_seq", "Hacl.Spec.SHA2.Vec.load_last_blocks", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Lib.Buffer.lbuffer_t", "Lib.IntTypes.int_t", "Lib.IntTypes.U8", "Lib.IntTypes.SEC", "Hacl.Impl.SHA2.Core.load_last_blocks", "Lib.Sequence.eq_intro", "Lib.Sequence.create", "Lib.IntTypes.u8", "Lib.Buffer.disjoint", "Lib.IntTypes.mul", "FStar.UInt32.uint_to_t", "FStar.UInt32.t", "Lib.Buffer.sub", "Lib.NTuple.tup4" ]	[]	false	false	false	false	false	let load_last4 #a #m totlen_buf len b fin last =	let h0 = ST.get () in let b0, (b1, (b2, b3)) = NTup.tup4 b in let last0 = sub last 0ul (2ul ! HD.block_len a) in let last1 = sub last (2ul ! HD.block_len a) (2ul ! HD.block_len a) in let last2 = sub last (4ul ! HD.block_len a) (2ul ! HD.block_len a) in let last3 = sub last (6ul ! HD.block_len a) (2ul ! HD.block_len a) in let h1 = ST.get () in assert (disjoint last0 last1); LSeq.eq_intro (as_seq h1 last0) (LSeq.create (2 block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last1) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last2) (LSeq.create (2 * block_length a) (u8 0)); LSeq.eq_intro (as_seq h1 last3) (LSeq.create (2 * block_length a) (u8 0)); let l00, l01 = load_last_blocks #a totlen_buf len b0 fin last0 in let l10, l11 = load_last_blocks #a totlen_buf len b1 fin last1 in let l20, l21 = load_last_blocks #a totlen_buf len b2 fin last2 in let l30, l31 = load_last_blocks #a totlen_buf len b3 fin last3 in let mb0:multibuf (lanes a m) (HD.block_len a) = ntup4 (l00, (l10, (l20, l30))) in let mb1:multibuf (lanes a m) (HD.block_len a) = ntup4 (l01, (l11, (l21, l31))) in let h1 = ST.get () in assert ((as_seq h1 l00, as_seq h1 l01) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b0)); assert ((as_seq h1 l10, as_seq h1 l11) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b1)); assert ((as_seq h1 l20, as_seq h1 l21) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b2)); assert ((as_seq h1 l30, as_seq h1 l31) == SpecVec.load_last_blocks #a (as_seq h0 totlen_buf) (v fin) (v len) (as_seq h0 b3)); NTup.eq_intro (as_seq_multi h1 mb0) (ntup4 (as_seq h1 l00, (as_seq h1 l10, (as_seq h1 l20, (as_seq h1 l30))))); NTup.eq_intro (as_seq_multi h1 mb1) (ntup4 (as_seq h1 l01, (as_seq h1 l11, (as_seq h1 l21, (as_seq h1 l31))))); assert (modifies (loc last0 \|+\| loc last1 \|+\| loc last2 \|+\| loc last3) h0 h1); assert (modifies (loc last) h0 h1); assert (live_multi h1 mb0); assert (live_multi h1 mb1); reveal_opaque (`%SpecVec.load_last) (SpecVec.load_last #a #m); (mb0, mb1)	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.jump_bounded_vldata_strong	val jump_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata_strong min max s))	val jump_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata_strong min max s))	let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 53, "end_line": 233, "start_col": 0, "start_line": 222 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat -> s: LowParse.Spec.Base.serializer p -> u189: u190: Prims.unit{min <= max /\ max > 0 /\ max < 4294967296} -> LowParse.Low.Base.jumper (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.unit", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Low.VLData.jump_bounded_vldata_strong'", "LowParse.Spec.BoundedInt.log256'", "LowParse.Low.Base.jumper", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong" ]	[]	false	false	false	false	false	let jump_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (jumper (parse_bounded_vldata_strong min max s)) =	jump_bounded_vldata_strong' min max (log256' max) s	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.jump_bounded_vldata_strong'	val jump_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s))	val jump_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s))	let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 44, "end_line": 219, "start_col": 0, "start_line": 204 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> s: LowParse.Spec.Base.serializer p -> LowParse.Low.Base.jumper (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.jump_bounded_vldata'", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong'", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.Base.jumper" ]	[]	false	false	false	false	false	let jump_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) =	fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@@ inline_let ]let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@@ inline_let ]let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.clens_bounded_vldata_strong_payload	val clens_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t)	val clens_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t)	let clens_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t) = { clens_cond = (fun _ -> True); clens_get = (fun (x: parse_bounded_vldata_strong_t min max s) -> (x <: t)); }	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 1, "end_line": 783, "start_col": 0, "start_line": 772 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p inline_for_extraction let accessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` U32.uint_to_t (log256' max)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> LowParse.Low.Base.Spec.clens (LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s) t	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.Spec.Mkclens", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "Prims.l_True", "LowParse.Low.Base.Spec.clens" ]	[]	false	false	false	false	false	let clens_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t) =	{ clens_cond = (fun _ -> True); clens_get = (fun (x: parse_bounded_vldata_strong_t min max s) -> (x <: t)) }	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_vldata_gen_elim	val valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_vldata_gen sz f p) h input pos)) (ensures (valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos))))	val valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_vldata_gen sz f p) h input pos)) (ensures (valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos))))	let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload)	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 77, "end_line": 76, "start_col": 0, "start_line": 46 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 4, "max_fuel": 8, "max_ifuel": 4, "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": 32, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	h: FStar.Monotonic.HyperStack.mem -> sz: LowParse.Spec.BoundedInt.integer_size -> f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_vldata_gen sz f p) h input pos) (ensures LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ (let len_payload = LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + FStar.UInt32.v len_payload == LowParse.Low.Base.Spec.content_length (LowParse.Spec.VLData.parse_vldata_gen sz f p) h input pos /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.VLData.parse_vldata_gen sz f p) h input pos (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.valid_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.contents_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) == LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_vldata_gen sz f p) h input pos)))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.Base.Spec.contents_exact_eq", "FStar.UInt32.add", "Prims.unit", "LowParse.Low.Base.Spec.valid_exact_equiv", "FStar.UInt32.uint_to_t", "LowParse.Low.Base.Spec.contents", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.parse_bounded_integer", "LowParse.Spec.VLData.parse_vldata_gen_eq", "LowParse.Slice.bytes_of_slice_from", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Low.Base.Spec.valid", "Prims.squash", "Prims.l_and", "Prims.eq2", "Prims.int", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Low.Base.Spec.content_length", "LowParse.Low.Base.Spec.valid_pos", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.contents_exact", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_vldata_gen sz f p) h input pos)) (ensures (valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos)))) =	valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload)	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.jump_bounded_vldata'	val jump_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p))	val jump_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p))	let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 52, "end_line": 150, "start_col": 0, "start_line": 133 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> p: LowParse.Spec.Base.parser k t -> LowParse.Low.Base.jumper (LowParse.Spec.VLData.parse_bounded_vldata' min max l p)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.jump_vldata_gen", "LowParse.Spec.BoundedInt.in_bounds", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata'", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.Base.jumper" ]	[]	false	false	false	false	false	let jump_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) =	fun #rrel #rel input pos -> let h = HST.get () in [@@ inline_let ]let sz = l in [@@ inline_let ]let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@@ inline_let ]let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_bounded_vldata_strong	val validate_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata_strong min max s))	val validate_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata_strong min max s))	let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 59, "end_line": 201, "start_col": 0, "start_line": 189 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat -> s: LowParse.Spec.Base.serializer p -> v: LowParse.Low.Base.validator p -> u162: u163: Prims.unit{min <= max /\ max > 0 /\ max < 4294967296} -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.validator", "Prims.unit", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Low.VLData.validate_bounded_vldata_strong'", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong" ]	[]	false	false	false	false	false	let validate_bounded_vldata_strong (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata_strong min max s)) =	validate_bounded_vldata_strong' min max (log256' max) s v	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_bounded_vldata	val validate_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata min max p))	val validate_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata min max p))	let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 50, "end_line": 130, "start_col": 0, "start_line": 117 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat -> v: LowParse.Low.Base.validator p -> u105: u106: Prims.unit{min <= max /\ max > 0 /\ max < 4294967296} -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_bounded_vldata min max p)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Low.Base.validator", "Prims.unit", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Low.VLData.validate_bounded_vldata'", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata" ]	[]	false	false	false	false	false	let validate_bounded_vldata (min max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit{min <= max /\ max > 0 /\ max < 4294967296}) : Tot (validator (parse_bounded_vldata min max p)) =	validate_bounded_vldata' min max (log256' max) v	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.finalize_vldata_gen	val finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true)))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	val finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true)))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 48, "end_line": 298, "start_col": 0, "start_line": 270 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	sz: LowParse.Spec.BoundedInt.integer_size -> f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_vldata_gen_intro", "Prims.unit", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.BoundedInt.write_bounded_integer", "FStar.UInt32.sub", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Spec.BoundedInt.bounded_integer_prop", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "Prims.eq2", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Low.Base.Spec.contents_exact" ]	[]	false	true	false	false	false	let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true)))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos')) =	[@@ inline_let ]let len_payload = pos' `U32.sub` (pos `U32.add` (U32.uint_to_t sz)) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos'	false
Test.Vectors.Chacha20Poly1305.fst	Test.Vectors.Chacha20Poly1305.output10	val output10:(b: B.buffer UInt8.t {B.length b = 1949 /\ B.recallable b})	val output10:(b: B.buffer UInt8.t {B.length b = 1949 /\ B.recallable b})	let output10: (b: B.buffer UInt8.t { B.length b = 1949 /\ B.recallable b }) = [@inline_let] let l = [ 0x6auy; 0xfcuy; 0x4buy; 0x25uy; 0xdfuy; 0xc0uy; 0xe4uy; 0xe8uy; 0x17uy; 0x4duy; 0x4cuy; 0xc9uy; 0x7euy; 0xdeuy; 0x3auy; 0xccuy; 0x3cuy; 0xbauy; 0x6auy; 0x77uy; 0x47uy; 0xdbuy; 0xe3uy; 0x74uy; 0x7auy; 0x4duy; 0x5fuy; 0x8duy; 0x37uy; 0x55uy; 0x80uy; 0x73uy; 0x90uy; 0x66uy; 0x5duy; 0x3auy; 0x7duy; 0x5duy; 0x86uy; 0x5euy; 0x8duy; 0xfduy; 0x83uy; 0xffuy; 0x4euy; 0x74uy; 0x6fuy; 0xf9uy; 0xe6uy; 0x70uy; 0x17uy; 0x70uy; 0x3euy; 0x96uy; 0xa7uy; 0x7euy; 0xcbuy; 0xabuy; 0x8fuy; 0x58uy; 0x24uy; 0x9buy; 0x01uy; 0xfduy; 0xcbuy; 0xe6uy; 0x4duy; 0x9buy; 0xf0uy; 0x88uy; 0x94uy; 0x57uy; 0x66uy; 0xefuy; 0x72uy; 0x4cuy; 0x42uy; 0x6euy; 0x16uy; 0x19uy; 0x15uy; 0xeauy; 0x70uy; 0x5buy; 0xacuy; 0x13uy; 0xdbuy; 0x9fuy; 0x18uy; 0xe2uy; 0x3cuy; 0x26uy; 0x97uy; 0xbcuy; 0xdcuy; 0x45uy; 0x8cuy; 0x6cuy; 0x24uy; 0x69uy; 0x9cuy; 0xf7uy; 0x65uy; 0x1euy; 0x18uy; 0x59uy; 0x31uy; 0x7cuy; 0xe4uy; 0x73uy; 0xbcuy; 0x39uy; 0x62uy; 0xc6uy; 0x5cuy; 0x9fuy; 0xbfuy; 0xfauy; 0x90uy; 0x03uy; 0xc9uy; 0x72uy; 0x26uy; 0xb6uy; 0x1buy; 0xc2uy; 0xb7uy; 0x3fuy; 0xf2uy; 0x13uy; 0x77uy; 0xf2uy; 0x8duy; 0xb9uy; 0x47uy; 0xd0uy; 0x53uy; 0xdduy; 0xc8uy; 0x91uy; 0x83uy; 0x8buy; 0xb1uy; 0xceuy; 0xa3uy; 0xfeuy; 0xcduy; 0xd9uy; 0xdduy; 0x92uy; 0x7buy; 0xdbuy; 0xb8uy; 0xfbuy; 0xc9uy; 0x2duy; 0x01uy; 0x59uy; 0x39uy; 0x52uy; 0xaduy; 0x1buy; 0xecuy; 0xcfuy; 0xd7uy; 0x70uy; 0x13uy; 0x21uy; 0xf5uy; 0x47uy; 0xaauy; 0x18uy; 0x21uy; 0x5cuy; 0xc9uy; 0x9auy; 0xd2uy; 0x6buy; 0x05uy; 0x9cuy; 0x01uy; 0xa1uy; 0xdauy; 0x35uy; 0x5duy; 0xb3uy; 0x70uy; 0xe6uy; 0xa9uy; 0x80uy; 0x8buy; 0x91uy; 0xb7uy; 0xb3uy; 0x5fuy; 0x24uy; 0x9auy; 0xb7uy; 0xd1uy; 0x6buy; 0xa1uy; 0x1cuy; 0x50uy; 0xbauy; 0x49uy; 0xe0uy; 0xeeuy; 0x2euy; 0x75uy; 0xacuy; 0x69uy; 0xc0uy; 0xebuy; 0x03uy; 0xdduy; 0x19uy; 0xe5uy; 0xf6uy; 0x06uy; 0xdduy; 0xc3uy; 0xd7uy; 0x2buy; 0x07uy; 0x07uy; 0x30uy; 0xa7uy; 0x19uy; 0x0cuy; 0xbfuy; 0xe6uy; 0x18uy; 0xccuy; 0xb1uy; 0x01uy; 0x11uy; 0x85uy; 0x77uy; 0x1duy; 0x96uy; 0xa7uy; 0xa3uy; 0x00uy; 0x84uy; 0x02uy; 0xa2uy; 0x83uy; 0x68uy; 0xdauy; 0x17uy; 0x27uy; 0xc8uy; 0x7fuy; 0x23uy; 0xb7uy; 0xf4uy; 0x13uy; 0x85uy; 0xcfuy; 0xdduy; 0x7auy; 0x7duy; 0x24uy; 0x57uy; 0xfeuy; 0x05uy; 0x93uy; 0xf5uy; 0x74uy; 0xceuy; 0xeduy; 0x0cuy; 0x20uy; 0x98uy; 0x8duy; 0x92uy; 0x30uy; 0xa1uy; 0x29uy; 0x23uy; 0x1auy; 0xa0uy; 0x4fuy; 0x69uy; 0x56uy; 0x4cuy; 0xe1uy; 0xc8uy; 0xceuy; 0xf6uy; 0x9auy; 0x0cuy; 0xa4uy; 0xfauy; 0x04uy; 0xf6uy; 0x62uy; 0x95uy; 0xf2uy; 0xfauy; 0xc7uy; 0x40uy; 0x68uy; 0x40uy; 0x8fuy; 0x41uy; 0xdauy; 0xb4uy; 0x26uy; 0x6fuy; 0x70uy; 0xabuy; 0x40uy; 0x61uy; 0xa4uy; 0x0euy; 0x75uy; 0xfbuy; 0x86uy; 0xebuy; 0x9duy; 0x9auy; 0x1fuy; 0xecuy; 0x76uy; 0x99uy; 0xe7uy; 0xeauy; 0xaauy; 0x1euy; 0x2duy; 0xb5uy; 0xd4uy; 0xa6uy; 0x1auy; 0xb8uy; 0x61uy; 0x0auy; 0x1duy; 0x16uy; 0x5buy; 0x98uy; 0xc2uy; 0x31uy; 0x40uy; 0xe7uy; 0x23uy; 0x1duy; 0x66uy; 0x99uy; 0xc8uy; 0xc0uy; 0xd7uy; 0xceuy; 0xf3uy; 0x57uy; 0x40uy; 0x04uy; 0x3fuy; 0xfcuy; 0xeauy; 0xb3uy; 0xfcuy; 0xd2uy; 0xd3uy; 0x99uy; 0xa4uy; 0x94uy; 0x69uy; 0xa0uy; 0xefuy; 0xd1uy; 0x85uy; 0xb3uy; 0xa6uy; 0xb1uy; 0x28uy; 0xbfuy; 0x94uy; 0x67uy; 0x22uy; 0xc3uy; 0x36uy; 0x46uy; 0xf8uy; 0xd2uy; 0x0fuy; 0x5fuy; 0xf4uy; 0x59uy; 0x80uy; 0xe6uy; 0x2duy; 0x43uy; 0x08uy; 0x7duy; 0x19uy; 0x09uy; 0x97uy; 0xa7uy; 0x4cuy; 0x3duy; 0x8duy; 0xbauy; 0x65uy; 0x62uy; 0xa3uy; 0x71uy; 0x33uy; 0x29uy; 0x62uy; 0xdbuy; 0xc1uy; 0x33uy; 0x34uy; 0x1auy; 0x63uy; 0x33uy; 0x16uy; 0xb6uy; 0x64uy; 0x7euy; 0xabuy; 0x33uy; 0xf0uy; 0xe6uy; 0x26uy; 0x68uy; 0xbauy; 0x1duy; 0x2euy; 0x38uy; 0x08uy; 0xe6uy; 0x02uy; 0xd3uy; 0x25uy; 0x2cuy; 0x47uy; 0x23uy; 0x58uy; 0x34uy; 0x0fuy; 0x9duy; 0x63uy; 0x4fuy; 0x63uy; 0xbbuy; 0x7fuy; 0x3buy; 0x34uy; 0x38uy; 0xa7uy; 0xb5uy; 0x8duy; 0x65uy; 0xd9uy; 0x9fuy; 0x79uy; 0x55uy; 0x3euy; 0x4duy; 0xe7uy; 0x73uy; 0xd8uy; 0xf6uy; 0x98uy; 0x97uy; 0x84uy; 0x60uy; 0x9cuy; 0xc8uy; 0xa9uy; 0x3cuy; 0xf6uy; 0xdcuy; 0x12uy; 0x5cuy; 0xe1uy; 0xbbuy; 0x0buy; 0x8buy; 0x98uy; 0x9cuy; 0x9duy; 0x26uy; 0x7cuy; 0x4auy; 0xe6uy; 0x46uy; 0x36uy; 0x58uy; 0x21uy; 0x4auy; 0xeeuy; 0xcauy; 0xd7uy; 0x3buy; 0xc2uy; 0x6cuy; 0x49uy; 0x2fuy; 0xe5uy; 0xd5uy; 0x03uy; 0x59uy; 0x84uy; 0x53uy; 0xcbuy; 0xfeuy; 0x92uy; 0x71uy; 0x2euy; 0x7cuy; 0x21uy; 0xccuy; 0x99uy; 0x85uy; 0x7fuy; 0xb8uy; 0x74uy; 0x90uy; 0x13uy; 0x42uy; 0x3fuy; 0xe0uy; 0x6buy; 0x1duy; 0xf2uy; 0x4duy; 0x54uy; 0xd4uy; 0xfcuy; 0x3auy; 0x05uy; 0xe6uy; 0x74uy; 0xafuy; 0xa6uy; 0xa0uy; 0x2auy; 0x20uy; 0x23uy; 0x5duy; 0x34uy; 0x5cuy; 0xd9uy; 0x3euy; 0x4euy; 0xfauy; 0x93uy; 0xe7uy; 0xaauy; 0xe9uy; 0x6fuy; 0x08uy; 0x43uy; 0x67uy; 0x41uy; 0xc5uy; 0xaduy; 0xfbuy; 0x31uy; 0x95uy; 0x82uy; 0x73uy; 0x32uy; 0xd8uy; 0xa6uy; 0xa3uy; 0xeduy; 0x0euy; 0x2duy; 0xf6uy; 0x5fuy; 0xfduy; 0x80uy; 0xa6uy; 0x7auy; 0xe0uy; 0xdfuy; 0x78uy; 0x15uy; 0x29uy; 0x74uy; 0x33uy; 0xd0uy; 0x9euy; 0x83uy; 0x86uy; 0x72uy; 0x22uy; 0x57uy; 0x29uy; 0xb9uy; 0x9euy; 0x5duy; 0xd3uy; 0x1auy; 0xb5uy; 0x96uy; 0x72uy; 0x41uy; 0x3duy; 0xf1uy; 0x64uy; 0x43uy; 0x67uy; 0xeeuy; 0xaauy; 0x5cuy; 0xd3uy; 0x9auy; 0x96uy; 0x13uy; 0x11uy; 0x5duy; 0xf3uy; 0x0cuy; 0x87uy; 0x82uy; 0x1euy; 0x41uy; 0x9euy; 0xd0uy; 0x27uy; 0xd7uy; 0x54uy; 0x3buy; 0x67uy; 0x73uy; 0x09uy; 0x91uy; 0xe9uy; 0xd5uy; 0x36uy; 0xa7uy; 0xb5uy; 0x55uy; 0xe4uy; 0xf3uy; 0x21uy; 0x51uy; 0x49uy; 0x22uy; 0x07uy; 0x55uy; 0x4fuy; 0x44uy; 0x4buy; 0xd2uy; 0x15uy; 0x93uy; 0x17uy; 0x2auy; 0xfauy; 0x4duy; 0x4auy; 0x57uy; 0xdbuy; 0x4cuy; 0xa6uy; 0xebuy; 0xecuy; 0x53uy; 0x25uy; 0x6cuy; 0x21uy; 0xeduy; 0x00uy; 0x4cuy; 0x3buy; 0xcauy; 0x14uy; 0x57uy; 0xa9uy; 0xd6uy; 0x6auy; 0xcduy; 0x8duy; 0x5euy; 0x74uy; 0xacuy; 0x72uy; 0xc1uy; 0x97uy; 0xe5uy; 0x1buy; 0x45uy; 0x4euy; 0xdauy; 0xfcuy; 0xccuy; 0x40uy; 0xe8uy; 0x48uy; 0x88uy; 0x0buy; 0xa3uy; 0xe3uy; 0x8duy; 0x83uy; 0x42uy; 0xc3uy; 0x23uy; 0xfduy; 0x68uy; 0xb5uy; 0x8euy; 0xf1uy; 0x9duy; 0x63uy; 0x77uy; 0xe9uy; 0xa3uy; 0x8euy; 0x8cuy; 0x26uy; 0x6buy; 0xbduy; 0x72uy; 0x73uy; 0x35uy; 0x0cuy; 0x03uy; 0xf8uy; 0x43uy; 0x78uy; 0x52uy; 0x71uy; 0x15uy; 0x1fuy; 0x71uy; 0x5duy; 0x6euy; 0xeduy; 0xb9uy; 0xccuy; 0x86uy; 0x30uy; 0xdbuy; 0x2buy; 0xd3uy; 0x82uy; 0x88uy; 0x23uy; 0x71uy; 0x90uy; 0x53uy; 0x5cuy; 0xa9uy; 0x2fuy; 0x76uy; 0x01uy; 0xb7uy; 0x9auy; 0xfeuy; 0x43uy; 0x55uy; 0xa3uy; 0x04uy; 0x9buy; 0x0euy; 0xe4uy; 0x59uy; 0xdfuy; 0xc9uy; 0xe9uy; 0xb1uy; 0xeauy; 0x29uy; 0x28uy; 0x3cuy; 0x5cuy; 0xaeuy; 0x72uy; 0x84uy; 0xb6uy; 0xc6uy; 0xebuy; 0x0cuy; 0x27uy; 0x07uy; 0x74uy; 0x90uy; 0x0duy; 0x31uy; 0xb0uy; 0x00uy; 0x77uy; 0xe9uy; 0x40uy; 0x70uy; 0x6fuy; 0x68uy; 0xa7uy; 0xfduy; 0x06uy; 0xecuy; 0x4buy; 0xc0uy; 0xb7uy; 0xacuy; 0xbcuy; 0x33uy; 0xb7uy; 0x6duy; 0x0auy; 0xbduy; 0x12uy; 0x1buy; 0x59uy; 0xcbuy; 0xdduy; 0x32uy; 0xf5uy; 0x1duy; 0x94uy; 0x57uy; 0x76uy; 0x9euy; 0x0cuy; 0x18uy; 0x98uy; 0x71uy; 0xd7uy; 0x2auy; 0xdbuy; 0x0buy; 0x7buy; 0xa7uy; 0x71uy; 0xb7uy; 0x67uy; 0x81uy; 0x23uy; 0x96uy; 0xaeuy; 0xb9uy; 0x7euy; 0x32uy; 0x43uy; 0x92uy; 0x8auy; 0x19uy; 0xa0uy; 0xc4uy; 0xd4uy; 0x3buy; 0x57uy; 0xf9uy; 0x4auy; 0x2cuy; 0xfbuy; 0x51uy; 0x46uy; 0xbbuy; 0xcbuy; 0x5duy; 0xb3uy; 0xefuy; 0x13uy; 0x93uy; 0x6euy; 0x68uy; 0x42uy; 0x54uy; 0x57uy; 0xd3uy; 0x6auy; 0x3auy; 0x8fuy; 0x9duy; 0x66uy; 0xbfuy; 0xbduy; 0x36uy; 0x23uy; 0xf5uy; 0x93uy; 0x83uy; 0x7buy; 0x9cuy; 0xc0uy; 0xdduy; 0xc5uy; 0x49uy; 0xc0uy; 0x64uy; 0xeduy; 0x07uy; 0x12uy; 0xb3uy; 0xe6uy; 0xe4uy; 0xe5uy; 0x38uy; 0x95uy; 0x23uy; 0xb1uy; 0xa0uy; 0x3buy; 0x1auy; 0x61uy; 0xdauy; 0x17uy; 0xacuy; 0xc3uy; 0x58uy; 0xdduy; 0x74uy; 0x64uy; 0x22uy; 0x11uy; 0xe8uy; 0x32uy; 0x1duy; 0x16uy; 0x93uy; 0x85uy; 0x99uy; 0xa5uy; 0x9cuy; 0x34uy; 0x55uy; 0xb1uy; 0xe9uy; 0x20uy; 0x72uy; 0xc9uy; 0x28uy; 0x7buy; 0x79uy; 0x00uy; 0xa1uy; 0xa6uy; 0xa3uy; 0x27uy; 0x40uy; 0x18uy; 0x8auy; 0x54uy; 0xe0uy; 0xccuy; 0xe8uy; 0x4euy; 0x8euy; 0x43uy; 0x96uy; 0xe7uy; 0x3fuy; 0xc8uy; 0xe9uy; 0xb2uy; 0xf9uy; 0xc9uy; 0xdauy; 0x04uy; 0x71uy; 0x50uy; 0x47uy; 0xe4uy; 0xaauy; 0xceuy; 0xa2uy; 0x30uy; 0xc8uy; 0xe4uy; 0xacuy; 0xc7uy; 0x0duy; 0x06uy; 0x2euy; 0xe6uy; 0xe8uy; 0x80uy; 0x36uy; 0x29uy; 0x9euy; 0x01uy; 0xb8uy; 0xc3uy; 0xf0uy; 0xa0uy; 0x5duy; 0x7auy; 0xcauy; 0x4duy; 0xa0uy; 0x57uy; 0xbduy; 0x2auy; 0x45uy; 0xa7uy; 0x7fuy; 0x9cuy; 0x93uy; 0x07uy; 0x8fuy; 0x35uy; 0x67uy; 0x92uy; 0xe3uy; 0xe9uy; 0x7fuy; 0xa8uy; 0x61uy; 0x43uy; 0x9euy; 0x25uy; 0x4fuy; 0x33uy; 0x76uy; 0x13uy; 0x6euy; 0x12uy; 0xb9uy; 0xdduy; 0xa4uy; 0x7cuy; 0x08uy; 0x9fuy; 0x7cuy; 0xe7uy; 0x0auy; 0x8duy; 0x84uy; 0x06uy; 0xa4uy; 0x33uy; 0x17uy; 0x34uy; 0x5euy; 0x10uy; 0x7cuy; 0xc0uy; 0xa8uy; 0x3duy; 0x1fuy; 0x42uy; 0x20uy; 0x51uy; 0x65uy; 0x5duy; 0x09uy; 0xc3uy; 0xaauy; 0xc0uy; 0xc8uy; 0x0duy; 0xf0uy; 0x79uy; 0xbcuy; 0x20uy; 0x1buy; 0x95uy; 0xe7uy; 0x06uy; 0x7duy; 0x47uy; 0x20uy; 0x03uy; 0x1auy; 0x74uy; 0xdduy; 0xe2uy; 0xd4uy; 0xaeuy; 0x38uy; 0x71uy; 0x9buy; 0xf5uy; 0x80uy; 0xecuy; 0x08uy; 0x4euy; 0x56uy; 0xbauy; 0x76uy; 0x12uy; 0x1auy; 0xdfuy; 0x48uy; 0xf3uy; 0xaeuy; 0xb3uy; 0xe6uy; 0xe6uy; 0xbeuy; 0xc0uy; 0x91uy; 0x2euy; 0x01uy; 0xb3uy; 0x01uy; 0x86uy; 0xa2uy; 0xb9uy; 0x52uy; 0xd1uy; 0x21uy; 0xaeuy; 0xd4uy; 0x97uy; 0x1duy; 0xefuy; 0x41uy; 0x12uy; 0x95uy; 0x3duy; 0x48uy; 0x45uy; 0x1cuy; 0x56uy; 0x32uy; 0x8fuy; 0xb8uy; 0x43uy; 0xbbuy; 0x19uy; 0xf3uy; 0xcauy; 0xe9uy; 0xebuy; 0x6duy; 0x84uy; 0xbeuy; 0x86uy; 0x06uy; 0xe2uy; 0x36uy; 0xb2uy; 0x62uy; 0x9duy; 0xd3uy; 0x4cuy; 0x48uy; 0x18uy; 0x54uy; 0x13uy; 0x4euy; 0xcfuy; 0xfduy; 0xbauy; 0x84uy; 0xb9uy; 0x30uy; 0x53uy; 0xcfuy; 0xfbuy; 0xb9uy; 0x29uy; 0x8fuy; 0xdcuy; 0x9fuy; 0xefuy; 0x60uy; 0x0buy; 0x64uy; 0xf6uy; 0x8buy; 0xeeuy; 0xa6uy; 0x91uy; 0xc2uy; 0x41uy; 0x6cuy; 0xf6uy; 0xfauy; 0x79uy; 0x67uy; 0x4buy; 0xc1uy; 0x3fuy; 0xafuy; 0x09uy; 0x81uy; 0xd4uy; 0x5duy; 0xcbuy; 0x09uy; 0xdfuy; 0x36uy; 0x31uy; 0xc0uy; 0x14uy; 0x3cuy; 0x7cuy; 0x0euy; 0x65uy; 0x95uy; 0x99uy; 0x6duy; 0xa3uy; 0xf4uy; 0xd7uy; 0x38uy; 0xeeuy; 0x1auy; 0x2buy; 0x37uy; 0xe2uy; 0xa4uy; 0x3buy; 0x4buy; 0xd0uy; 0x65uy; 0xcauy; 0xf8uy; 0xc3uy; 0xe8uy; 0x15uy; 0x20uy; 0xefuy; 0xf2uy; 0x00uy; 0xfduy; 0x01uy; 0x09uy; 0xc5uy; 0xc8uy; 0x17uy; 0x04uy; 0x93uy; 0xd0uy; 0x93uy; 0x03uy; 0x55uy; 0xc5uy; 0xfeuy; 0x32uy; 0xa3uy; 0x3euy; 0x28uy; 0x2duy; 0x3buy; 0x93uy; 0x8auy; 0xccuy; 0x07uy; 0x72uy; 0x80uy; 0x8buy; 0x74uy; 0x16uy; 0x24uy; 0xbbuy; 0xdauy; 0x94uy; 0x39uy; 0x30uy; 0x8fuy; 0xb1uy; 0xcduy; 0x4auy; 0x90uy; 0x92uy; 0x7cuy; 0x14uy; 0x8fuy; 0x95uy; 0x4euy; 0xacuy; 0x9buy; 0xd8uy; 0x8fuy; 0x1auy; 0x87uy; 0xa4uy; 0x32uy; 0x27uy; 0x8auy; 0xbauy; 0xf7uy; 0x41uy; 0xcfuy; 0x84uy; 0x37uy; 0x19uy; 0xe6uy; 0x06uy; 0xf5uy; 0x0euy; 0xcfuy; 0x36uy; 0xf5uy; 0x9euy; 0x6cuy; 0xdeuy; 0xbcuy; 0xffuy; 0x64uy; 0x7euy; 0x4euy; 0x59uy; 0x57uy; 0x48uy; 0xfeuy; 0x14uy; 0xf7uy; 0x9cuy; 0x93uy; 0x5duy; 0x15uy; 0xaduy; 0xccuy; 0x11uy; 0xb1uy; 0x17uy; 0x18uy; 0xb2uy; 0x7euy; 0xccuy; 0xabuy; 0xe9uy; 0xceuy; 0x7duy; 0x77uy; 0x5buy; 0x51uy; 0x1buy; 0x1euy; 0x20uy; 0xa8uy; 0x32uy; 0x06uy; 0x0euy; 0x75uy; 0x93uy; 0xacuy; 0xdbuy; 0x35uy; 0x37uy; 0x1fuy; 0xe9uy; 0x19uy; 0x1duy; 0xb4uy; 0x71uy; 0x97uy; 0xd6uy; 0x4euy; 0x2cuy; 0x08uy; 0xa5uy; 0x13uy; 0xf9uy; 0x0euy; 0x7euy; 0x78uy; 0x6euy; 0x14uy; 0xe0uy; 0xa9uy; 0xb9uy; 0x96uy; 0x4cuy; 0x80uy; 0x82uy; 0xbauy; 0x17uy; 0xb3uy; 0x9duy; 0x69uy; 0xb0uy; 0x84uy; 0x46uy; 0xffuy; 0xf9uy; 0x52uy; 0x79uy; 0x94uy; 0x58uy; 0x3auy; 0x62uy; 0x90uy; 0x15uy; 0x35uy; 0x71uy; 0x10uy; 0x37uy; 0xeduy; 0xa1uy; 0x8euy; 0x53uy; 0x6euy; 0xf4uy; 0x26uy; 0x57uy; 0x93uy; 0x15uy; 0x93uy; 0xf6uy; 0x81uy; 0x2cuy; 0x5auy; 0x10uy; 0xdauy; 0x92uy; 0xaduy; 0x2fuy; 0xdbuy; 0x28uy; 0x31uy; 0x2duy; 0x55uy; 0x04uy; 0xd2uy; 0x06uy; 0x28uy; 0x8cuy; 0x1euy; 0xdcuy; 0xeauy; 0x54uy; 0xacuy; 0xffuy; 0xb7uy; 0x6cuy; 0x30uy; 0x15uy; 0xd4uy; 0xb4uy; 0x0duy; 0x00uy; 0x93uy; 0x57uy; 0xdduy; 0xd2uy; 0x07uy; 0x07uy; 0x06uy; 0xd9uy; 0x43uy; 0x9buy; 0xcduy; 0x3auy; 0xf4uy; 0x7duy; 0x4cuy; 0x36uy; 0x5duy; 0x23uy; 0xa2uy; 0xccuy; 0x57uy; 0x40uy; 0x91uy; 0xe9uy; 0x2cuy; 0x2fuy; 0x2cuy; 0xd5uy; 0x30uy; 0x9buy; 0x17uy; 0xb0uy; 0xc9uy; 0xf7uy; 0xa7uy; 0x2fuy; 0xd1uy; 0x93uy; 0x20uy; 0x6buy; 0xc6uy; 0xc1uy; 0xe4uy; 0x6fuy; 0xcbuy; 0xd1uy; 0xe7uy; 0x09uy; 0x0fuy; 0x9euy; 0xdcuy; 0xaauy; 0x9fuy; 0x2fuy; 0xdfuy; 0x56uy; 0x9fuy; 0xd4uy; 0x33uy; 0x04uy; 0xafuy; 0xd3uy; 0x6cuy; 0x58uy; 0x61uy; 0xf0uy; 0x30uy; 0xecuy; 0xf2uy; 0x7fuy; 0xf2uy; 0x9cuy; 0xdfuy; 0x39uy; 0xbbuy; 0x6fuy; 0xa2uy; 0x8cuy; 0x7euy; 0xc4uy; 0x22uy; 0x51uy; 0x71uy; 0xc0uy; 0x4duy; 0x14uy; 0x1auy; 0xc4uy; 0xcduy; 0x04uy; 0xd9uy; 0x87uy; 0x08uy; 0x50uy; 0x05uy; 0xccuy; 0xafuy; 0xf6uy; 0xf0uy; 0x8fuy; 0x92uy; 0x54uy; 0x58uy; 0xc2uy; 0xc7uy; 0x09uy; 0x7auy; 0x59uy; 0x02uy; 0x05uy; 0xe8uy; 0xb0uy; 0x86uy; 0xd9uy; 0xbfuy; 0x7buy; 0x35uy; 0x51uy; 0x4duy; 0xafuy; 0x08uy; 0x97uy; 0x2cuy; 0x65uy; 0xdauy; 0x2auy; 0x71uy; 0x3auy; 0xa8uy; 0x51uy; 0xccuy; 0xf2uy; 0x73uy; 0x27uy; 0xc3uy; 0xfduy; 0x62uy; 0xcfuy; 0xe3uy; 0xb2uy; 0xcauy; 0xcbuy; 0xbeuy; 0x1auy; 0x0auy; 0xa1uy; 0x34uy; 0x7buy; 0x77uy; 0xc4uy; 0x62uy; 0x68uy; 0x78uy; 0x5fuy; 0x94uy; 0x07uy; 0x04uy; 0x65uy; 0x16uy; 0x4buy; 0x61uy; 0xcbuy; 0xffuy; 0x75uy; 0x26uy; 0x50uy; 0x66uy; 0x1fuy; 0x6euy; 0x93uy; 0xf8uy; 0xc5uy; 0x51uy; 0xebuy; 0xa4uy; 0x4auy; 0x48uy; 0x68uy; 0x6buy; 0xe2uy; 0x5euy; 0x44uy; 0xb2uy; 0x50uy; 0x2cuy; 0x6cuy; 0xaeuy; 0x79uy; 0x4euy; 0x66uy; 0x35uy; 0x81uy; 0x50uy; 0xacuy; 0xbcuy; 0x3fuy; 0xb1uy; 0x0cuy; 0xf3uy; 0x05uy; 0x3cuy; 0x4auy; 0xa3uy; 0x6cuy; 0x2auy; 0x79uy; 0xb4uy; 0xb7uy; 0xabuy; 0xcauy; 0xc7uy; 0x9buy; 0x8euy; 0xcduy; 0x5fuy; 0x11uy; 0x03uy; 0xcbuy; 0x30uy; 0xa3uy; 0xabuy; 0xdauy; 0xfeuy; 0x64uy; 0xb9uy; 0xbbuy; 0xd8uy; 0x5euy; 0x3auy; 0x1auy; 0x56uy; 0xe5uy; 0x05uy; 0x48uy; 0x90uy; 0x1euy; 0x61uy; 0x69uy; 0x1buy; 0x22uy; 0xe6uy; 0x1auy; 0x3cuy; 0x75uy; 0xaduy; 0x1fuy; 0x37uy; 0x28uy; 0xdcuy; 0xe4uy; 0x6duy; 0xbduy; 0x42uy; 0xdcuy; 0xd3uy; 0xc8uy; 0xb6uy; 0x1cuy; 0x48uy; 0xfeuy; 0x94uy; 0x77uy; 0x7fuy; 0xbduy; 0x62uy; 0xacuy; 0xa3uy; 0x47uy; 0x27uy; 0xcfuy; 0x5fuy; 0xd9uy; 0xdbuy; 0xafuy; 0xecuy; 0xf7uy; 0x5euy; 0xc1uy; 0xb0uy; 0x9duy; 0x01uy; 0x26uy; 0x99uy; 0x7euy; 0x8fuy; 0x03uy; 0x70uy; 0xb5uy; 0x42uy; 0xbeuy; 0x67uy; 0x28uy; 0x1buy; 0x7cuy; 0xbduy; 0x61uy; 0x21uy; 0x97uy; 0xccuy; 0x5cuy; 0xe1uy; 0x97uy; 0x8fuy; 0x8duy; 0xdeuy; 0x2buy; 0xaauy; 0xa7uy; 0x71uy; 0x1duy; 0x1euy; 0x02uy; 0x73uy; 0x70uy; 0x58uy; 0x32uy; 0x5buy; 0x1duy; 0x67uy; 0x3duy; 0xe0uy; 0x74uy; 0x4fuy; 0x03uy; 0xf2uy; 0x70uy; 0x51uy; 0x79uy; 0xf1uy; 0x61uy; 0x70uy; 0x15uy; 0x74uy; 0x9duy; 0x23uy; 0x89uy; 0xdeuy; 0xacuy; 0xfduy; 0xdeuy; 0xd0uy; 0x1fuy; 0xc3uy; 0x87uy; 0x44uy; 0x35uy; 0x4buy; 0xe5uy; 0xb0uy; 0x60uy; 0xc5uy; 0x22uy; 0xe4uy; 0x9euy; 0xcauy; 0xebuy; 0xd5uy; 0x3auy; 0x09uy; 0x45uy; 0xa4uy; 0xdbuy; 0xfauy; 0x3fuy; 0xebuy; 0x1buy; 0xc7uy; 0xc8uy; 0x14uy; 0x99uy; 0x51uy; 0x92uy; 0x10uy; 0xeduy; 0xeduy; 0x28uy; 0xe0uy; 0xa1uy; 0xf8uy; 0x26uy; 0xcfuy; 0xcduy; 0xcbuy; 0x63uy; 0xa1uy; 0x3buy; 0xe3uy; 0xdfuy; 0x7euy; 0xfeuy; 0xa6uy; 0xf0uy; 0x81uy; 0x9auy; 0xbfuy; 0x55uy; 0xdeuy; 0x54uy; 0xd5uy; 0x56uy; 0x60uy; 0x98uy; 0x10uy; 0x68uy; 0xf4uy; 0x38uy; 0x96uy; 0x8euy; 0x6fuy; 0x1duy; 0x44uy; 0x7fuy; 0xd6uy; 0x2fuy; 0xfeuy; 0x55uy; 0xfbuy; 0x0cuy; 0x7euy; 0x67uy; 0xe2uy; 0x61uy; 0x44uy; 0xeduy; 0xf2uy; 0x35uy; 0x30uy; 0x5duy; 0xe9uy; 0xc7uy; 0xd6uy; 0x6duy; 0xe0uy; 0xa0uy; 0xeduy; 0xf3uy; 0xfcuy; 0xd8uy; 0x3euy; 0x0auy; 0x7buy; 0xcduy; 0xafuy; 0x65uy; 0x68uy; 0x18uy; 0xc0uy; 0xecuy; 0x04uy; 0x1cuy; 0x74uy; 0x6duy; 0xe2uy; 0x6euy; 0x79uy; 0xd4uy; 0x11uy; 0x2buy; 0x62uy; 0xd5uy; 0x27uy; 0xaduy; 0x4fuy; 0x01uy; 0x59uy; 0x73uy; 0xccuy; 0x6auy; 0x53uy; 0xfbuy; 0x2duy; 0xd5uy; 0x4euy; 0x99uy; 0x21uy; 0x65uy; 0x4duy; 0xf5uy; 0x82uy; 0xf7uy; 0xd8uy; 0x42uy; 0xceuy; 0x6fuy; 0x3duy; 0x36uy; 0x47uy; 0xf1uy; 0x05uy; 0x16uy; 0xe8uy; 0x1buy; 0x6auy; 0x8fuy; 0x93uy; 0xf2uy; 0x8fuy; 0x37uy; 0x40uy; 0x12uy; 0x28uy; 0xa3uy; 0xe6uy; 0xb9uy; 0x17uy; 0x4auy; 0x1fuy; 0xb1uy; 0xd1uy; 0x66uy; 0x69uy; 0x86uy; 0xc4uy; 0xfcuy; 0x97uy; 0xaeuy; 0x3fuy; 0x8fuy; 0x1euy; 0x2buy; 0xdfuy; 0xcduy; 0xf9uy; 0x3cuy; ] in assert_norm (List.Tot.length l = 1949); B.gcmalloc_of_list HyperStack.root l	{ "file_name": "providers/test/vectors/Test.Vectors.Chacha20Poly1305.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 38, "end_line": 442, "start_col": 0, "start_line": 439 }	module Test.Vectors.Chacha20Poly1305 module B = LowStar.Buffer #set-options "--max_fuel 0 --max_ifuel 0" let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x1cuy; 0x92uy; 0x40uy; 0xa5uy; 0xebuy; 0x55uy; 0xd3uy; 0x8auy; 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x04uy; 0xf6uy; 0xb5uy; 0xf0uy; 0x47uy; 0x39uy; 0x17uy; 0xc1uy; 0x40uy; 0x2buy; 0x80uy; 0x09uy; 0x9duy; 0xcauy; 0x5cuy; 0xbcuy; 0x20uy; 0x70uy; 0x75uy; 0xc0uy; ] 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 nonce0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce0_len: (x:UInt32.t { UInt32.v x = B.length nonce0 }) = 12ul let aad0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x4euy; 0x91uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad0_len: (x:UInt32.t { UInt32.v x = B.length aad0 }) = 12ul let input0: (b: B.buffer UInt8.t { B.length b = 265 /\ B.recallable b /\ B.disjoint b aad0 }) = B.recall aad0;[@inline_let] let l = [ 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x72uy; 0x65uy; 0x20uy; 0x64uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x76uy; 0x61uy; 0x6cuy; 0x69uy; 0x64uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x61uy; 0x20uy; 0x6duy; 0x61uy; 0x78uy; 0x69uy; 0x6duy; 0x75uy; 0x6duy; 0x20uy; 0x6fuy; 0x66uy; 0x20uy; 0x73uy; 0x69uy; 0x78uy; 0x20uy; 0x6duy; 0x6fuy; 0x6euy; 0x74uy; 0x68uy; 0x73uy; 0x20uy; 0x61uy; 0x6euy; 0x64uy; 0x20uy; 0x6duy; 0x61uy; 0x79uy; 0x20uy; 0x62uy; 0x65uy; 0x20uy; 0x75uy; 0x70uy; 0x64uy; 0x61uy; 0x74uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x72uy; 0x65uy; 0x70uy; 0x6cuy; 0x61uy; 0x63uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x6fuy; 0x62uy; 0x73uy; 0x6fuy; 0x6cuy; 0x65uy; 0x74uy; 0x65uy; 0x64uy; 0x20uy; 0x62uy; 0x79uy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x74uy; 0x20uy; 0x61uy; 0x6euy; 0x79uy; 0x20uy; 0x74uy; 0x69uy; 0x6duy; 0x65uy; 0x2euy; 0x20uy; 0x49uy; 0x74uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x6euy; 0x61uy; 0x70uy; 0x70uy; 0x72uy; 0x6fuy; 0x70uy; 0x72uy; 0x69uy; 0x61uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x75uy; 0x73uy; 0x65uy; 0x20uy; 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x72uy; 0x65uy; 0x66uy; 0x65uy; 0x72uy; 0x65uy; 0x6euy; 0x63uy; 0x65uy; 0x20uy; 0x6duy; 0x61uy; 0x74uy; 0x65uy; 0x72uy; 0x69uy; 0x61uy; 0x6cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x63uy; 0x69uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x68uy; 0x65uy; 0x6duy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x74uy; 0x68uy; 0x61uy; 0x6euy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x2fuy; 0xe2uy; 0x80uy; 0x9cuy; 0x77uy; 0x6fuy; 0x72uy; 0x6buy; 0x20uy; 0x69uy; 0x6euy; 0x20uy; 0x70uy; 0x72uy; 0x6fuy; 0x67uy; 0x72uy; 0x65uy; 0x73uy; 0x73uy; 0x2euy; 0x2fuy; 0xe2uy; 0x80uy; 0x9duy; ] in assert_norm (List.Tot.length l = 265); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) = 265ul let output0: (b: B.buffer UInt8.t { B.length b = 281 /\ B.recallable b }) = [@inline_let] let l = [ 0x64uy; 0xa0uy; 0x86uy; 0x15uy; 0x75uy; 0x86uy; 0x1auy; 0xf4uy; 0x60uy; 0xf0uy; 0x62uy; 0xc7uy; 0x9buy; 0xe6uy; 0x43uy; 0xbduy; 0x5euy; 0x80uy; 0x5cuy; 0xfduy; 0x34uy; 0x5cuy; 0xf3uy; 0x89uy; 0xf1uy; 0x08uy; 0x67uy; 0x0auy; 0xc7uy; 0x6cuy; 0x8cuy; 0xb2uy; 0x4cuy; 0x6cuy; 0xfcuy; 0x18uy; 0x75uy; 0x5duy; 0x43uy; 0xeeuy; 0xa0uy; 0x9euy; 0xe9uy; 0x4euy; 0x38uy; 0x2duy; 0x26uy; 0xb0uy; 0xbduy; 0xb7uy; 0xb7uy; 0x3cuy; 0x32uy; 0x1buy; 0x01uy; 0x00uy; 0xd4uy; 0xf0uy; 0x3buy; 0x7fuy; 0x35uy; 0x58uy; 0x94uy; 0xcfuy; 0x33uy; 0x2fuy; 0x83uy; 0x0euy; 0x71uy; 0x0buy; 0x97uy; 0xceuy; 0x98uy; 0xc8uy; 0xa8uy; 0x4auy; 0xbduy; 0x0buy; 0x94uy; 0x81uy; 0x14uy; 0xaduy; 0x17uy; 0x6euy; 0x00uy; 0x8duy; 0x33uy; 0xbduy; 0x60uy; 0xf9uy; 0x82uy; 0xb1uy; 0xffuy; 0x37uy; 0xc8uy; 0x55uy; 0x97uy; 0x97uy; 0xa0uy; 0x6euy; 0xf4uy; 0xf0uy; 0xefuy; 0x61uy; 0xc1uy; 0x86uy; 0x32uy; 0x4euy; 0x2buy; 0x35uy; 0x06uy; 0x38uy; 0x36uy; 0x06uy; 0x90uy; 0x7buy; 0x6auy; 0x7cuy; 0x02uy; 0xb0uy; 0xf9uy; 0xf6uy; 0x15uy; 0x7buy; 0x53uy; 0xc8uy; 0x67uy; 0xe4uy; 0xb9uy; 0x16uy; 0x6cuy; 0x76uy; 0x7buy; 0x80uy; 0x4duy; 0x46uy; 0xa5uy; 0x9buy; 0x52uy; 0x16uy; 0xcduy; 0xe7uy; 0xa4uy; 0xe9uy; 0x90uy; 0x40uy; 0xc5uy; 0xa4uy; 0x04uy; 0x33uy; 0x22uy; 0x5euy; 0xe2uy; 0x82uy; 0xa1uy; 0xb0uy; 0xa0uy; 0x6cuy; 0x52uy; 0x3euy; 0xafuy; 0x45uy; 0x34uy; 0xd7uy; 0xf8uy; 0x3fuy; 0xa1uy; 0x15uy; 0x5buy; 0x00uy; 0x47uy; 0x71uy; 0x8cuy; 0xbcuy; 0x54uy; 0x6auy; 0x0duy; 0x07uy; 0x2buy; 0x04uy; 0xb3uy; 0x56uy; 0x4euy; 0xeauy; 0x1buy; 0x42uy; 0x22uy; 0x73uy; 0xf5uy; 0x48uy; 0x27uy; 0x1auy; 0x0buy; 0xb2uy; 0x31uy; 0x60uy; 0x53uy; 0xfauy; 0x76uy; 0x99uy; 0x19uy; 0x55uy; 0xebuy; 0xd6uy; 0x31uy; 0x59uy; 0x43uy; 0x4euy; 0xceuy; 0xbbuy; 0x4euy; 0x46uy; 0x6duy; 0xaeuy; 0x5auy; 0x10uy; 0x73uy; 0xa6uy; 0x72uy; 0x76uy; 0x27uy; 0x09uy; 0x7auy; 0x10uy; 0x49uy; 0xe6uy; 0x17uy; 0xd9uy; 0x1duy; 0x36uy; 0x10uy; 0x94uy; 0xfauy; 0x68uy; 0xf0uy; 0xffuy; 0x77uy; 0x98uy; 0x71uy; 0x30uy; 0x30uy; 0x5buy; 0xeauy; 0xbauy; 0x2euy; 0xdauy; 0x04uy; 0xdfuy; 0x99uy; 0x7buy; 0x71uy; 0x4duy; 0x6cuy; 0x6fuy; 0x2cuy; 0x29uy; 0xa6uy; 0xaduy; 0x5cuy; 0xb4uy; 0x02uy; 0x2buy; 0x02uy; 0x70uy; 0x9buy; 0xeeuy; 0xaduy; 0x9duy; 0x67uy; 0x89uy; 0x0cuy; 0xbbuy; 0x22uy; 0x39uy; 0x23uy; 0x36uy; 0xfeuy; 0xa1uy; 0x85uy; 0x1fuy; 0x38uy; ] in assert_norm (List.Tot.length l = 281); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output0_len: (x:UInt32.t { UInt32.v x = B.length output0 }) = 281ul let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x4cuy; 0xf5uy; 0x96uy; 0x83uy; 0x38uy; 0xe6uy; 0xaeuy; 0x7fuy; 0x2duy; 0x29uy; 0x25uy; 0x76uy; 0xd5uy; 0x75uy; 0x27uy; 0x86uy; 0x91uy; 0x9auy; 0x27uy; 0x7auy; 0xfbuy; 0x46uy; 0xc5uy; 0xefuy; 0x94uy; 0x81uy; 0x79uy; 0x57uy; 0x14uy; 0x59uy; 0x40uy; 0x68uy; ] 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 nonce1: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcauy; 0xbfuy; 0x33uy; 0x71uy; 0x32uy; 0x45uy; 0x77uy; 0x8euy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce1_len: (x:UInt32.t { UInt32.v x = B.length nonce1 }) = 12ul let aad1: (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 aad1_len: (x:UInt32.t { UInt32.v x = B.length aad1 }) = 0ul let input1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad1 }) = B.recall aad1;[@inline_let] let l = [ ] in assert_norm (List.Tot.length l = 0); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) = 0ul let output1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xeauy; 0xe0uy; 0x1euy; 0x9euy; 0x2cuy; 0x91uy; 0xaauy; 0xe1uy; 0xdbuy; 0x5duy; 0x99uy; 0x3fuy; 0x8auy; 0xf7uy; 0x69uy; 0x92uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output1_len: (x:UInt32.t { UInt32.v x = B.length output1 }) = 16ul let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x2duy; 0xb0uy; 0x5duy; 0x40uy; 0xc8uy; 0xeduy; 0x44uy; 0x88uy; 0x34uy; 0xd1uy; 0x13uy; 0xafuy; 0x57uy; 0xa1uy; 0xebuy; 0x3auy; 0x2auy; 0x80uy; 0x51uy; 0x36uy; 0xecuy; 0x5buy; 0xbcuy; 0x08uy; 0x93uy; 0x84uy; 0x21uy; 0xb5uy; 0x13uy; 0x88uy; 0x3cuy; 0x0duy; ] 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 nonce2: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x3duy; 0x86uy; 0xb5uy; 0x6buy; 0xc8uy; 0xa3uy; 0x1fuy; 0x1duy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce2_len: (x:UInt32.t { UInt32.v x = B.length nonce2 }) = 12ul let aad2: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) = [@inline_let] let l = [ 0x33uy; 0x10uy; 0x41uy; 0x12uy; 0x1fuy; 0xf3uy; 0xd2uy; 0x6buy; ] in assert_norm (List.Tot.length l = 8); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad2_len: (x:UInt32.t { UInt32.v x = B.length aad2 }) = 8ul let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad2 }) = B.recall aad2;[@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 output2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xdduy; 0x6buy; 0x3buy; 0x82uy; 0xceuy; 0x5auy; 0xbduy; 0xd6uy; 0xa9uy; 0x35uy; 0x83uy; 0xd8uy; 0x8cuy; 0x3duy; 0x85uy; 0x77uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output2_len: (x:UInt32.t { UInt32.v x = B.length output2 }) = 16ul let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x4buy; 0x28uy; 0x4buy; 0xa3uy; 0x7buy; 0xbeuy; 0xe9uy; 0xf8uy; 0x31uy; 0x80uy; 0x82uy; 0xd7uy; 0xd8uy; 0xe8uy; 0xb5uy; 0xa1uy; 0xe2uy; 0x18uy; 0x18uy; 0x8auy; 0x9cuy; 0xfauy; 0xa3uy; 0x3duy; 0x25uy; 0x71uy; 0x3euy; 0x40uy; 0xbcuy; 0x54uy; 0x7auy; 0x3euy; ] 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 nonce3: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xd2uy; 0x32uy; 0x1fuy; 0x29uy; 0x28uy; 0xc6uy; 0xc4uy; 0xc4uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce3_len: (x:UInt32.t { UInt32.v x = B.length nonce3 }) = 12ul let aad3: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) = [@inline_let] let l = [ 0x6auy; 0xe2uy; 0xaduy; 0x3fuy; 0x88uy; 0x39uy; 0x5auy; 0x40uy; ] in assert_norm (List.Tot.length l = 8); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad3_len: (x:UInt32.t { UInt32.v x = B.length aad3 }) = 8ul let input3: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad3 }) = B.recall aad3;[@inline_let] let l = [ 0xa4uy; ] in assert_norm (List.Tot.length l = 1); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) = 1ul let output3: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) = [@inline_let] let l = [ 0xb7uy; 0x1buy; 0xb0uy; 0x73uy; 0x59uy; 0xb0uy; 0x84uy; 0xb2uy; 0x6duy; 0x8euy; 0xabuy; 0x94uy; 0x31uy; 0xa1uy; 0xaeuy; 0xacuy; 0x89uy; ] in assert_norm (List.Tot.length l = 17); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output3_len: (x:UInt32.t { UInt32.v x = B.length output3 }) = 17ul let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x66uy; 0xcauy; 0x9cuy; 0x23uy; 0x2auy; 0x4buy; 0x4buy; 0x31uy; 0x0euy; 0x92uy; 0x89uy; 0x8buy; 0xf4uy; 0x93uy; 0xc7uy; 0x87uy; 0x98uy; 0xa3uy; 0xd8uy; 0x39uy; 0xf8uy; 0xf4uy; 0xa7uy; 0x01uy; 0xc0uy; 0x2euy; 0x0auy; 0xa6uy; 0x7euy; 0x5auy; 0x78uy; 0x87uy; ] 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 nonce4: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x1cuy; 0xaauy; 0x5fuy; 0x9cuy; 0xbfuy; 0x92uy; 0x30uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce4_len: (x:UInt32.t { UInt32.v x = B.length nonce4 }) = 12ul let aad4: (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 aad4_len: (x:UInt32.t { UInt32.v x = B.length aad4 }) = 0ul let input4: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad4 }) = B.recall aad4;[@inline_let] let l = [ 0x2duy; ] in assert_norm (List.Tot.length l = 1); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) = 1ul let output4: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) = [@inline_let] let l = [ 0xbfuy; 0xe1uy; 0x5buy; 0x0buy; 0xdbuy; 0x6buy; 0xf5uy; 0x5euy; 0x6cuy; 0x5duy; 0x84uy; 0x44uy; 0x39uy; 0x81uy; 0xc1uy; 0x9cuy; 0xacuy; ] in assert_norm (List.Tot.length l = 17); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output4_len: (x:UInt32.t { UInt32.v x = B.length output4 }) = 17ul let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x68uy; 0x7buy; 0x8duy; 0x8euy; 0xe3uy; 0xc4uy; 0xdduy; 0xaeuy; 0xdfuy; 0x72uy; 0x7fuy; 0x53uy; 0x72uy; 0x25uy; 0x1euy; 0x78uy; 0x91uy; 0xcbuy; 0x69uy; 0x76uy; 0x1fuy; 0x49uy; 0x93uy; 0xf9uy; 0x6fuy; 0x21uy; 0xccuy; 0x39uy; 0x9cuy; 0xaduy; 0xb1uy; 0x01uy; ] 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 nonce5: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdfuy; 0x51uy; 0x84uy; 0x82uy; 0x42uy; 0x0cuy; 0x75uy; 0x9cuy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce5_len: (x:UInt32.t { UInt32.v x = B.length nonce5 }) = 12ul let aad5: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) = [@inline_let] let l = [ 0x70uy; 0xd3uy; 0x33uy; 0xf3uy; 0x8buy; 0x18uy; 0x0buy; ] in assert_norm (List.Tot.length l = 7); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad5_len: (x:UInt32.t { UInt32.v x = B.length aad5 }) = 7ul let input5: (b: B.buffer UInt8.t { B.length b = 129 /\ B.recallable b /\ B.disjoint b aad5 }) = B.recall aad5;[@inline_let] let l = [ 0x33uy; 0x2fuy; 0x94uy; 0xc1uy; 0xa4uy; 0xefuy; 0xccuy; 0x2auy; 0x5buy; 0xa6uy; 0xe5uy; 0x8fuy; 0x1duy; 0x40uy; 0xf0uy; 0x92uy; 0x3cuy; 0xd9uy; 0x24uy; 0x11uy; 0xa9uy; 0x71uy; 0xf9uy; 0x37uy; 0x14uy; 0x99uy; 0xfauy; 0xbeuy; 0xe6uy; 0x80uy; 0xdeuy; 0x50uy; 0xc9uy; 0x96uy; 0xd4uy; 0xb0uy; 0xecuy; 0x9euy; 0x17uy; 0xecuy; 0xd2uy; 0x5euy; 0x72uy; 0x99uy; 0xfcuy; 0x0auy; 0xe1uy; 0xcbuy; 0x48uy; 0xd2uy; 0x85uy; 0xdduy; 0x2fuy; 0x90uy; 0xe0uy; 0x66uy; 0x3buy; 0xe6uy; 0x20uy; 0x74uy; 0xbeuy; 0x23uy; 0x8fuy; 0xcbuy; 0xb4uy; 0xe4uy; 0xdauy; 0x48uy; 0x40uy; 0xa6uy; 0xd1uy; 0x1buy; 0xc7uy; 0x42uy; 0xceuy; 0x2fuy; 0x0cuy; 0xa6uy; 0x85uy; 0x6euy; 0x87uy; 0x37uy; 0x03uy; 0xb1uy; 0x7cuy; 0x25uy; 0x96uy; 0xa3uy; 0x05uy; 0xd8uy; 0xb0uy; 0xf4uy; 0xeduy; 0xeauy; 0xc2uy; 0xf0uy; 0x31uy; 0x98uy; 0x6cuy; 0xd1uy; 0x14uy; 0x25uy; 0xc0uy; 0xcbuy; 0x01uy; 0x74uy; 0xd0uy; 0x82uy; 0xf4uy; 0x36uy; 0xf5uy; 0x41uy; 0xd5uy; 0xdcuy; 0xcauy; 0xc5uy; 0xbbuy; 0x98uy; 0xfeuy; 0xfcuy; 0x69uy; 0x21uy; 0x70uy; 0xd8uy; 0xa4uy; 0x4buy; 0xc8uy; 0xdeuy; 0x8fuy; ] in assert_norm (List.Tot.length l = 129); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) = 129ul let output5: (b: B.buffer UInt8.t { B.length b = 145 /\ B.recallable b }) = [@inline_let] let l = [ 0x8buy; 0x06uy; 0xd3uy; 0x31uy; 0xb0uy; 0x93uy; 0x45uy; 0xb1uy; 0x75uy; 0x6euy; 0x26uy; 0xf9uy; 0x67uy; 0xbcuy; 0x90uy; 0x15uy; 0x81uy; 0x2cuy; 0xb5uy; 0xf0uy; 0xc6uy; 0x2buy; 0xc7uy; 0x8cuy; 0x56uy; 0xd1uy; 0xbfuy; 0x69uy; 0x6cuy; 0x07uy; 0xa0uy; 0xdauy; 0x65uy; 0x27uy; 0xc9uy; 0x90uy; 0x3duy; 0xefuy; 0x4buy; 0x11uy; 0x0fuy; 0x19uy; 0x07uy; 0xfduy; 0x29uy; 0x92uy; 0xd9uy; 0xc8uy; 0xf7uy; 0x99uy; 0x2euy; 0x4auy; 0xd0uy; 0xb8uy; 0x2cuy; 0xdcuy; 0x93uy; 0xf5uy; 0x9euy; 0x33uy; 0x78uy; 0xd1uy; 0x37uy; 0xc3uy; 0x66uy; 0xd7uy; 0x5euy; 0xbcuy; 0x44uy; 0xbfuy; 0x53uy; 0xa5uy; 0xbcuy; 0xc4uy; 0xcbuy; 0x7buy; 0x3auy; 0x8euy; 0x7fuy; 0x02uy; 0xbduy; 0xbbuy; 0xe7uy; 0xcauy; 0xa6uy; 0x6cuy; 0x6buy; 0x93uy; 0x21uy; 0x93uy; 0x10uy; 0x61uy; 0xe7uy; 0x69uy; 0xd0uy; 0x78uy; 0xf3uy; 0x07uy; 0x5auy; 0x1auy; 0x8fuy; 0x73uy; 0xaauy; 0xb1uy; 0x4euy; 0xd3uy; 0xdauy; 0x4fuy; 0xf3uy; 0x32uy; 0xe1uy; 0x66uy; 0x3euy; 0x6cuy; 0xc6uy; 0x13uy; 0xbauy; 0x06uy; 0x5buy; 0xfcuy; 0x6auy; 0xe5uy; 0x6fuy; 0x60uy; 0xfbuy; 0x07uy; 0x40uy; 0xb0uy; 0x8cuy; 0x9duy; 0x84uy; 0x43uy; 0x6buy; 0xc1uy; 0xf7uy; 0x8duy; 0x8duy; 0x31uy; 0xf7uy; 0x7auy; 0x39uy; 0x4duy; 0x8fuy; 0x9auy; 0xebuy; ] in assert_norm (List.Tot.length l = 145); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output5_len: (x:UInt32.t { UInt32.v x = B.length output5 }) = 145ul let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x8duy; 0xb8uy; 0x91uy; 0x48uy; 0xf0uy; 0xe7uy; 0x0auy; 0xbduy; 0xf9uy; 0x3fuy; 0xcduy; 0xd9uy; 0xa0uy; 0x1euy; 0x42uy; 0x4cuy; 0xe7uy; 0xdeuy; 0x25uy; 0x3duy; 0xa3uy; 0xd7uy; 0x05uy; 0x80uy; 0x8duy; 0xf2uy; 0x82uy; 0xacuy; 0x44uy; 0x16uy; 0x51uy; 0x01uy; ] 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 nonce6: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdeuy; 0x7buy; 0xefuy; 0xc3uy; 0x65uy; 0x1buy; 0x68uy; 0xb0uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce6_len: (x:UInt32.t { UInt32.v x = B.length nonce6 }) = 12ul let aad6: (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 aad6_len: (x:UInt32.t { UInt32.v x = B.length aad6 }) = 0ul let input6: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b /\ B.disjoint b aad6 }) = B.recall aad6;[@inline_let] let l = [ 0x9buy; 0x18uy; 0xdbuy; 0xdduy; 0x9auy; 0x0fuy; 0x3euy; 0xa5uy; 0x15uy; 0x17uy; 0xdeuy; 0xdfuy; 0x08uy; 0x9duy; 0x65uy; 0x0auy; 0x67uy; 0x30uy; 0x12uy; 0xe2uy; 0x34uy; 0x77uy; 0x4buy; 0xc1uy; 0xd9uy; 0xc6uy; 0x1fuy; 0xabuy; 0xc6uy; 0x18uy; 0x50uy; 0x17uy; 0xa7uy; 0x9duy; 0x3cuy; 0xa6uy; 0xc5uy; 0x35uy; 0x8cuy; 0x1cuy; 0xc0uy; 0xa1uy; 0x7cuy; 0x9fuy; 0x03uy; 0x89uy; 0xcauy; 0xe1uy; 0xe6uy; 0xe9uy; 0xd4uy; 0xd3uy; 0x88uy; 0xdbuy; 0xb4uy; 0x51uy; 0x9duy; 0xecuy; 0xb4uy; 0xfcuy; 0x52uy; 0xeeuy; 0x6duy; 0xf1uy; 0x75uy; 0x42uy; 0xc6uy; 0xfduy; 0xbduy; 0x7auy; 0x8euy; 0x86uy; 0xfcuy; 0x44uy; 0xb3uy; 0x4fuy; 0xf3uy; 0xeauy; 0x67uy; 0x5auy; 0x41uy; 0x13uy; 0xbauy; 0xb0uy; 0xdcuy; 0xe1uy; 0xd3uy; 0x2auy; 0x7cuy; 0x22uy; 0xb3uy; 0xcauy; 0xacuy; 0x6auy; 0x37uy; 0x98uy; 0x3euy; 0x1duy; 0x40uy; 0x97uy; 0xf7uy; 0x9buy; 0x1duy; 0x36uy; 0x6buy; 0xb3uy; 0x28uy; 0xbduy; 0x60uy; 0x82uy; 0x47uy; 0x34uy; 0xaauy; 0x2fuy; 0x7duy; 0xe9uy; 0xa8uy; 0x70uy; 0x81uy; 0x57uy; 0xd4uy; 0xb9uy; 0x77uy; 0x0auy; 0x9duy; 0x29uy; 0xa7uy; 0x84uy; 0x52uy; 0x4fuy; 0xc2uy; 0x4auy; 0x40uy; 0x3buy; 0x3cuy; 0xd4uy; 0xc9uy; 0x2auy; 0xdbuy; 0x4auy; 0x53uy; 0xc4uy; 0xbeuy; 0x80uy; 0xe9uy; 0x51uy; 0x7fuy; 0x8fuy; 0xc7uy; 0xa2uy; 0xceuy; 0x82uy; 0x5cuy; 0x91uy; 0x1euy; 0x74uy; 0xd9uy; 0xd0uy; 0xbduy; 0xd5uy; 0xf3uy; 0xfduy; 0xdauy; 0x4duy; 0x25uy; 0xb4uy; 0xbbuy; 0x2duy; 0xacuy; 0x2fuy; 0x3duy; 0x71uy; 0x85uy; 0x7buy; 0xcfuy; 0x3cuy; 0x7buy; 0x3euy; 0x0euy; 0x22uy; 0x78uy; 0x0cuy; 0x29uy; 0xbfuy; 0xe4uy; 0xf4uy; 0x57uy; 0xb3uy; 0xcbuy; 0x49uy; 0xa0uy; 0xfcuy; 0x1euy; 0x05uy; 0x4euy; 0x16uy; 0xbcuy; 0xd5uy; 0xa8uy; 0xa3uy; 0xeeuy; 0x05uy; 0x35uy; 0xc6uy; 0x7cuy; 0xabuy; 0x60uy; 0x14uy; 0x55uy; 0x1auy; 0x8euy; 0xc5uy; 0x88uy; 0x5duy; 0xd5uy; 0x81uy; 0xc2uy; 0x81uy; 0xa5uy; 0xc4uy; 0x60uy; 0xdbuy; 0xafuy; 0x77uy; 0x91uy; 0xe1uy; 0xceuy; 0xa2uy; 0x7euy; 0x7fuy; 0x42uy; 0xe3uy; 0xb0uy; 0x13uy; 0x1cuy; 0x1fuy; 0x25uy; 0x60uy; 0x21uy; 0xe2uy; 0x40uy; 0x5fuy; 0x99uy; 0xb7uy; 0x73uy; 0xecuy; 0x9buy; 0x2buy; 0xf0uy; 0x65uy; 0x11uy; 0xc8uy; 0xd0uy; 0x0auy; 0x9fuy; 0xd3uy; ] in assert_norm (List.Tot.length l = 256); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) = 256ul let output6: (b: B.buffer UInt8.t { B.length b = 272 /\ B.recallable b }) = [@inline_let] let l = [ 0x85uy; 0x04uy; 0xc2uy; 0xeduy; 0x8duy; 0xfduy; 0x97uy; 0x5cuy; 0xd2uy; 0xb7uy; 0xe2uy; 0xc1uy; 0x6buy; 0xa3uy; 0xbauy; 0xf8uy; 0xc9uy; 0x50uy; 0xc3uy; 0xc6uy; 0xa5uy; 0xe3uy; 0xa4uy; 0x7cuy; 0xc3uy; 0x23uy; 0x49uy; 0x5euy; 0xa9uy; 0xb9uy; 0x32uy; 0xebuy; 0x8auy; 0x7cuy; 0xcauy; 0xe5uy; 0xecuy; 0xfbuy; 0x7cuy; 0xc0uy; 0xcbuy; 0x7duy; 0xdcuy; 0x2cuy; 0x9duy; 0x92uy; 0x55uy; 0x21uy; 0x0auy; 0xc8uy; 0x43uy; 0x63uy; 0x59uy; 0x0auy; 0x31uy; 0x70uy; 0x82uy; 0x67uy; 0x41uy; 0x03uy; 0xf8uy; 0xdfuy; 0xf2uy; 0xacuy; 0xa7uy; 0x02uy; 0xd4uy; 0xd5uy; 0x8auy; 0x2duy; 0xc8uy; 0x99uy; 0x19uy; 0x66uy; 0xd0uy; 0xf6uy; 0x88uy; 0x2cuy; 0x77uy; 0xd9uy; 0xd4uy; 0x0duy; 0x6cuy; 0xbduy; 0x98uy; 0xdeuy; 0xe7uy; 0x7fuy; 0xaduy; 0x7euy; 0x8auy; 0xfbuy; 0xe9uy; 0x4buy; 0xe5uy; 0xf7uy; 0xe5uy; 0x50uy; 0xa0uy; 0x90uy; 0x3fuy; 0xd6uy; 0x22uy; 0x53uy; 0xe3uy; 0xfeuy; 0x1buy; 0xccuy; 0x79uy; 0x3buy; 0xecuy; 0x12uy; 0x47uy; 0x52uy; 0xa7uy; 0xd6uy; 0x04uy; 0xe3uy; 0x52uy; 0xe6uy; 0x93uy; 0x90uy; 0x91uy; 0x32uy; 0x73uy; 0x79uy; 0xb8uy; 0xd0uy; 0x31uy; 0xdeuy; 0x1fuy; 0x9fuy; 0x2fuy; 0x05uy; 0x38uy; 0x54uy; 0x2fuy; 0x35uy; 0x04uy; 0x39uy; 0xe0uy; 0xa7uy; 0xbauy; 0xc6uy; 0x52uy; 0xf6uy; 0x37uy; 0x65uy; 0x4cuy; 0x07uy; 0xa9uy; 0x7euy; 0xb3uy; 0x21uy; 0x6fuy; 0x74uy; 0x8cuy; 0xc9uy; 0xdeuy; 0xdbuy; 0x65uy; 0x1buy; 0x9buy; 0xaauy; 0x60uy; 0xb1uy; 0x03uy; 0x30uy; 0x6buy; 0xb2uy; 0x03uy; 0xc4uy; 0x1cuy; 0x04uy; 0xf8uy; 0x0fuy; 0x64uy; 0xafuy; 0x46uy; 0xe4uy; 0x65uy; 0x99uy; 0x49uy; 0xe2uy; 0xeauy; 0xceuy; 0x78uy; 0x00uy; 0xd8uy; 0x8buy; 0xd5uy; 0x2euy; 0xcfuy; 0xfcuy; 0x40uy; 0x49uy; 0xe8uy; 0x58uy; 0xdcuy; 0x34uy; 0x9cuy; 0x8cuy; 0x61uy; 0xbfuy; 0x0auy; 0x8euy; 0xecuy; 0x39uy; 0xa9uy; 0x30uy; 0x05uy; 0x5auy; 0xd2uy; 0x56uy; 0x01uy; 0xc7uy; 0xdauy; 0x8fuy; 0x4euy; 0xbbuy; 0x43uy; 0xa3uy; 0x3auy; 0xf9uy; 0x15uy; 0x2auy; 0xd0uy; 0xa0uy; 0x7auy; 0x87uy; 0x34uy; 0x82uy; 0xfeuy; 0x8auy; 0xd1uy; 0x2duy; 0x5euy; 0xc7uy; 0xbfuy; 0x04uy; 0x53uy; 0x5fuy; 0x3buy; 0x36uy; 0xd4uy; 0x25uy; 0x5cuy; 0x34uy; 0x7auy; 0x8duy; 0xd5uy; 0x05uy; 0xceuy; 0x72uy; 0xcauy; 0xefuy; 0x7auy; 0x4buy; 0xbcuy; 0xb0uy; 0x10uy; 0x5cuy; 0x96uy; 0x42uy; 0x3auy; 0x00uy; 0x98uy; 0xcduy; 0x15uy; 0xe8uy; 0xb7uy; 0x53uy; ] in assert_norm (List.Tot.length l = 272); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output6_len: (x:UInt32.t { UInt32.v x = B.length output6 }) = 272ul let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0xf2uy; 0xaauy; 0x4fuy; 0x99uy; 0xfduy; 0x3euy; 0xa8uy; 0x53uy; 0xc1uy; 0x44uy; 0xe9uy; 0x81uy; 0x18uy; 0xdcuy; 0xf5uy; 0xf0uy; 0x3euy; 0x44uy; 0x15uy; 0x59uy; 0xe0uy; 0xc5uy; 0x44uy; 0x86uy; 0xc3uy; 0x91uy; 0xa8uy; 0x75uy; 0xc0uy; 0x12uy; 0x46uy; 0xbauy; ] 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 nonce7: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0euy; 0x0duy; 0x57uy; 0xbbuy; 0x7buy; 0x40uy; 0x54uy; 0x02uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce7_len: (x:UInt32.t { UInt32.v x = B.length nonce7 }) = 12ul let aad7: (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 aad7_len: (x:UInt32.t { UInt32.v x = B.length aad7 }) = 0ul let input7: (b: B.buffer UInt8.t { B.length b = 512 /\ B.recallable b /\ B.disjoint b aad7 }) = B.recall aad7;[@inline_let] let l = [ 0xc3uy; 0x09uy; 0x94uy; 0x62uy; 0xe6uy; 0x46uy; 0x2euy; 0x10uy; 0xbeuy; 0x00uy; 0xe4uy; 0xfcuy; 0xf3uy; 0x40uy; 0xa3uy; 0xe2uy; 0x0fuy; 0xc2uy; 0x8buy; 0x28uy; 0xdcuy; 0xbauy; 0xb4uy; 0x3cuy; 0xe4uy; 0x21uy; 0x58uy; 0x61uy; 0xcduy; 0x8buy; 0xcduy; 0xfbuy; 0xacuy; 0x94uy; 0xa1uy; 0x45uy; 0xf5uy; 0x1cuy; 0xe1uy; 0x12uy; 0xe0uy; 0x3buy; 0x67uy; 0x21uy; 0x54uy; 0x5euy; 0x8cuy; 0xaauy; 0xcfuy; 0xdbuy; 0xb4uy; 0x51uy; 0xd4uy; 0x13uy; 0xdauy; 0xe6uy; 0x83uy; 0x89uy; 0xb6uy; 0x92uy; 0xe9uy; 0x21uy; 0x76uy; 0xa4uy; 0x93uy; 0x7duy; 0x0euy; 0xfduy; 0x96uy; 0x36uy; 0x03uy; 0x91uy; 0x43uy; 0x5cuy; 0x92uy; 0x49uy; 0x62uy; 0x61uy; 0x7buy; 0xebuy; 0x43uy; 0x89uy; 0xb8uy; 0x12uy; 0x20uy; 0x43uy; 0xd4uy; 0x47uy; 0x06uy; 0x84uy; 0xeeuy; 0x47uy; 0xe9uy; 0x8auy; 0x73uy; 0x15uy; 0x0fuy; 0x72uy; 0xcfuy; 0xeduy; 0xceuy; 0x96uy; 0xb2uy; 0x7fuy; 0x21uy; 0x45uy; 0x76uy; 0xebuy; 0x26uy; 0x28uy; 0x83uy; 0x6auy; 0xaduy; 0xaauy; 0xa6uy; 0x81uy; 0xd8uy; 0x55uy; 0xb1uy; 0xa3uy; 0x85uy; 0xb3uy; 0x0cuy; 0xdfuy; 0xf1uy; 0x69uy; 0x2duy; 0x97uy; 0x05uy; 0x2auy; 0xbcuy; 0x7cuy; 0x7buy; 0x25uy; 0xf8uy; 0x80uy; 0x9duy; 0x39uy; 0x25uy; 0xf3uy; 0x62uy; 0xf0uy; 0x66uy; 0x5euy; 0xf4uy; 0xa0uy; 0xcfuy; 0xd8uy; 0xfduy; 0x4fuy; 0xb1uy; 0x1fuy; 0x60uy; 0x3auy; 0x08uy; 0x47uy; 0xafuy; 0xe1uy; 0xf6uy; 0x10uy; 0x77uy; 0x09uy; 0xa7uy; 0x27uy; 0x8fuy; 0x9auy; 0x97uy; 0x5auy; 0x26uy; 0xfauy; 0xfeuy; 0x41uy; 0x32uy; 0x83uy; 0x10uy; 0xe0uy; 0x1duy; 0xbfuy; 0x64uy; 0x0duy; 0xf4uy; 0x1cuy; 0x32uy; 0x35uy; 0xe5uy; 0x1buy; 0x36uy; 0xefuy; 0xd4uy; 0x4auy; 0x93uy; 0x4duy; 0x00uy; 0x7cuy; 0xecuy; 0x02uy; 0x07uy; 0x8buy; 0x5duy; 0x7duy; 0x1buy; 0x0euy; 0xd1uy; 0xa6uy; 0xa5uy; 0x5duy; 0x7duy; 0x57uy; 0x88uy; 0xa8uy; 0xccuy; 0x81uy; 0xb4uy; 0x86uy; 0x4euy; 0xb4uy; 0x40uy; 0xe9uy; 0x1duy; 0xc3uy; 0xb1uy; 0x24uy; 0x3euy; 0x7fuy; 0xccuy; 0x8auy; 0x24uy; 0x9buy; 0xdfuy; 0x6duy; 0xf0uy; 0x39uy; 0x69uy; 0x3euy; 0x4cuy; 0xc0uy; 0x96uy; 0xe4uy; 0x13uy; 0xdauy; 0x90uy; 0xdauy; 0xf4uy; 0x95uy; 0x66uy; 0x8buy; 0x17uy; 0x17uy; 0xfeuy; 0x39uy; 0x43uy; 0x25uy; 0xaauy; 0xdauy; 0xa0uy; 0x43uy; 0x3cuy; 0xb1uy; 0x41uy; 0x02uy; 0xa3uy; 0xf0uy; 0xa7uy; 0x19uy; 0x59uy; 0xbcuy; 0x1duy; 0x7duy; 0x6cuy; 0x6duy; 0x91uy; 0x09uy; 0x5cuy; 0xb7uy; 0x5buy; 0x01uy; 0xd1uy; 0x6fuy; 0x17uy; 0x21uy; 0x97uy; 0xbfuy; 0x89uy; 0x71uy; 0xa5uy; 0xb0uy; 0x6euy; 0x07uy; 0x45uy; 0xfduy; 0x9duy; 0xeauy; 0x07uy; 0xf6uy; 0x7auy; 0x9fuy; 0x10uy; 0x18uy; 0x22uy; 0x30uy; 0x73uy; 0xacuy; 0xd4uy; 0x6buy; 0x72uy; 0x44uy; 0xeduy; 0xd9uy; 0x19uy; 0x9buy; 0x2duy; 0x4auy; 0x41uy; 0xdduy; 0xd1uy; 0x85uy; 0x5euy; 0x37uy; 0x19uy; 0xeduy; 0xd2uy; 0x15uy; 0x8fuy; 0x5euy; 0x91uy; 0xdbuy; 0x33uy; 0xf2uy; 0xe4uy; 0xdbuy; 0xffuy; 0x98uy; 0xfbuy; 0xa3uy; 0xb5uy; 0xcauy; 0x21uy; 0x69uy; 0x08uy; 0xe7uy; 0x8auy; 0xdfuy; 0x90uy; 0xffuy; 0x3euy; 0xe9uy; 0x20uy; 0x86uy; 0x3cuy; 0xe9uy; 0xfcuy; 0x0buy; 0xfeuy; 0x5cuy; 0x61uy; 0xaauy; 0x13uy; 0x92uy; 0x7fuy; 0x7buy; 0xecuy; 0xe0uy; 0x6duy; 0xa8uy; 0x23uy; 0x22uy; 0xf6uy; 0x6buy; 0x77uy; 0xc4uy; 0xfeuy; 0x40uy; 0x07uy; 0x3buy; 0xb6uy; 0xf6uy; 0x8euy; 0x5fuy; 0xd4uy; 0xb9uy; 0xb7uy; 0x0fuy; 0x21uy; 0x04uy; 0xefuy; 0x83uy; 0x63uy; 0x91uy; 0x69uy; 0x40uy; 0xa3uy; 0x48uy; 0x5cuy; 0xd2uy; 0x60uy; 0xf9uy; 0x4fuy; 0x6cuy; 0x47uy; 0x8buy; 0x3buy; 0xb1uy; 0x9fuy; 0x8euy; 0xeeuy; 0x16uy; 0x8auy; 0x13uy; 0xfcuy; 0x46uy; 0x17uy; 0xc3uy; 0xc3uy; 0x32uy; 0x56uy; 0xf8uy; 0x3cuy; 0x85uy; 0x3auy; 0xb6uy; 0x3euy; 0xaauy; 0x89uy; 0x4fuy; 0xb3uy; 0xdfuy; 0x38uy; 0xfduy; 0xf1uy; 0xe4uy; 0x3auy; 0xc0uy; 0xe6uy; 0x58uy; 0xb5uy; 0x8fuy; 0xc5uy; 0x29uy; 0xa2uy; 0x92uy; 0x4auy; 0xb6uy; 0xa0uy; 0x34uy; 0x7fuy; 0xabuy; 0xb5uy; 0x8auy; 0x90uy; 0xa1uy; 0xdbuy; 0x4duy; 0xcauy; 0xb6uy; 0x2cuy; 0x41uy; 0x3cuy; 0xf7uy; 0x2buy; 0x21uy; 0xc3uy; 0xfduy; 0xf4uy; 0x17uy; 0x5cuy; 0xb5uy; 0x33uy; 0x17uy; 0x68uy; 0x2buy; 0x08uy; 0x30uy; 0xf3uy; 0xf7uy; 0x30uy; 0x3cuy; 0x96uy; 0xe6uy; 0x6auy; 0x20uy; 0x97uy; 0xe7uy; 0x4duy; 0x10uy; 0x5fuy; 0x47uy; 0x5fuy; 0x49uy; 0x96uy; 0x09uy; 0xf0uy; 0x27uy; 0x91uy; 0xc8uy; 0xf8uy; 0x5auy; 0x2euy; 0x79uy; 0xb5uy; 0xe2uy; 0xb8uy; 0xe8uy; 0xb9uy; 0x7buy; 0xd5uy; 0x10uy; 0xcbuy; 0xffuy; 0x5duy; 0x14uy; 0x73uy; 0xf3uy; ] in assert_norm (List.Tot.length l = 512); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) = 512ul let output7: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) = [@inline_let] let l = [ 0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy; 0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy; 0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy; 0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy; 0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy; 0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy; 0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy; 0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy; 0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy; 0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy; 0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy; 0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy; 0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy; 0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy; 0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy; 0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy; 0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy; 0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy; 0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy; 0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy; 0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy; 0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy; 0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy; 0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy; 0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy; 0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy; 0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy; 0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy; 0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy; 0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy; 0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy; 0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy; 0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy; 0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy; 0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy; 0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy; 0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy; 0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy; 0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy; 0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy; 0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy; 0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy; 0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy; 0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy; ] in assert_norm (List.Tot.length l = 528); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output7_len: (x:UInt32.t { UInt32.v x = B.length output7 }) = 528ul let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0xeauy; 0xbcuy; 0x56uy; 0x99uy; 0xe3uy; 0x50uy; 0xffuy; 0xc5uy; 0xccuy; 0x1auy; 0xd7uy; 0xc1uy; 0x57uy; 0x72uy; 0xeauy; 0x86uy; 0x5buy; 0x89uy; 0x88uy; 0x61uy; 0x3duy; 0x2fuy; 0x9buy; 0xb2uy; 0xe7uy; 0x9cuy; 0xecuy; 0x74uy; 0x6euy; 0x3euy; 0xf4uy; 0x3buy; ] 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 nonce8: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xefuy; 0x2duy; 0x63uy; 0xeeuy; 0x6buy; 0x80uy; 0x8buy; 0x78uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce8_len: (x:UInt32.t { UInt32.v x = B.length nonce8 }) = 12ul let aad8: (b: B.buffer UInt8.t { B.length b = 9 /\ B.recallable b }) = [@inline_let] let l = [ 0x5auy; 0x27uy; 0xffuy; 0xebuy; 0xdfuy; 0x84uy; 0xb2uy; 0x9euy; 0xefuy; ] in assert_norm (List.Tot.length l = 9); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad8_len: (x:UInt32.t { UInt32.v x = B.length aad8 }) = 9ul let input8: (b: B.buffer UInt8.t { B.length b = 513 /\ B.recallable b /\ B.disjoint b aad8 }) = B.recall aad8;[@inline_let] let l = [ 0xe6uy; 0xc3uy; 0xdbuy; 0x63uy; 0x55uy; 0x15uy; 0xe3uy; 0x5buy; 0xb7uy; 0x4buy; 0x27uy; 0x8buy; 0x5auy; 0xdduy; 0xc2uy; 0xe8uy; 0x3auy; 0x6buy; 0xd7uy; 0x81uy; 0x96uy; 0x35uy; 0x97uy; 0xcauy; 0xd7uy; 0x68uy; 0xe8uy; 0xefuy; 0xceuy; 0xabuy; 0xdauy; 0x09uy; 0x6euy; 0xd6uy; 0x8euy; 0xcbuy; 0x55uy; 0xb5uy; 0xe1uy; 0xe5uy; 0x57uy; 0xfduy; 0xc4uy; 0xe3uy; 0xe0uy; 0x18uy; 0x4fuy; 0x85uy; 0xf5uy; 0x3fuy; 0x7euy; 0x4buy; 0x88uy; 0xc9uy; 0x52uy; 0x44uy; 0x0fuy; 0xeauy; 0xafuy; 0x1fuy; 0x71uy; 0x48uy; 0x9fuy; 0x97uy; 0x6duy; 0xb9uy; 0x6fuy; 0x00uy; 0xa6uy; 0xdeuy; 0x2buy; 0x77uy; 0x8buy; 0x15uy; 0xaduy; 0x10uy; 0xa0uy; 0x2buy; 0x7buy; 0x41uy; 0x90uy; 0x03uy; 0x2duy; 0x69uy; 0xaeuy; 0xccuy; 0x77uy; 0x7cuy; 0xa5uy; 0x9duy; 0x29uy; 0x22uy; 0xc2uy; 0xeauy; 0xb4uy; 0x00uy; 0x1auy; 0xd2uy; 0x7auy; 0x98uy; 0x8auy; 0xf9uy; 0xf7uy; 0x82uy; 0xb0uy; 0xabuy; 0xd8uy; 0xa6uy; 0x94uy; 0x8duy; 0x58uy; 0x2fuy; 0x01uy; 0x9euy; 0x00uy; 0x20uy; 0xfcuy; 0x49uy; 0xdcuy; 0x0euy; 0x03uy; 0xe8uy; 0x45uy; 0x10uy; 0xd6uy; 0xa8uy; 0xdauy; 0x55uy; 0x10uy; 0x9auy; 0xdfuy; 0x67uy; 0x22uy; 0x8buy; 0x43uy; 0xabuy; 0x00uy; 0xbbuy; 0x02uy; 0xc8uy; 0xdduy; 0x7buy; 0x97uy; 0x17uy; 0xd7uy; 0x1duy; 0x9euy; 0x02uy; 0x5euy; 0x48uy; 0xdeuy; 0x8euy; 0xcfuy; 0x99uy; 0x07uy; 0x95uy; 0x92uy; 0x3cuy; 0x5fuy; 0x9fuy; 0xc5uy; 0x8auy; 0xc0uy; 0x23uy; 0xaauy; 0xd5uy; 0x8cuy; 0x82uy; 0x6euy; 0x16uy; 0x92uy; 0xb1uy; 0x12uy; 0x17uy; 0x07uy; 0xc3uy; 0xfbuy; 0x36uy; 0xf5uy; 0x6cuy; 0x35uy; 0xd6uy; 0x06uy; 0x1fuy; 0x9fuy; 0xa7uy; 0x94uy; 0xa2uy; 0x38uy; 0x63uy; 0x9cuy; 0xb0uy; 0x71uy; 0xb3uy; 0xa5uy; 0xd2uy; 0xd8uy; 0xbauy; 0x9fuy; 0x08uy; 0x01uy; 0xb3uy; 0xffuy; 0x04uy; 0x97uy; 0x73uy; 0x45uy; 0x1buy; 0xd5uy; 0xa9uy; 0x9cuy; 0x80uy; 0xafuy; 0x04uy; 0x9auy; 0x85uy; 0xdbuy; 0x32uy; 0x5buy; 0x5duy; 0x1auy; 0xc1uy; 0x36uy; 0x28uy; 0x10uy; 0x79uy; 0xf1uy; 0x3cuy; 0xbfuy; 0x1auy; 0x41uy; 0x5cuy; 0x4euy; 0xdfuy; 0xb2uy; 0x7cuy; 0x79uy; 0x3buy; 0x7auy; 0x62uy; 0x3duy; 0x4buy; 0xc9uy; 0x9buy; 0x2auy; 0x2euy; 0x7cuy; 0xa2uy; 0xb1uy; 0x11uy; 0x98uy; 0xa7uy; 0x34uy; 0x1auy; 0x00uy; 0xf3uy; 0xd1uy; 0xbcuy; 0x18uy; 0x22uy; 0xbauy; 0x02uy; 0x56uy; 0x62uy; 0x31uy; 0x10uy; 0x11uy; 0x6duy; 0xe0uy; 0x54uy; 0x9duy; 0x40uy; 0x1fuy; 0x26uy; 0x80uy; 0x41uy; 0xcauy; 0x3fuy; 0x68uy; 0x0fuy; 0x32uy; 0x1duy; 0x0auy; 0x8euy; 0x79uy; 0xd8uy; 0xa4uy; 0x1buy; 0x29uy; 0x1cuy; 0x90uy; 0x8euy; 0xc5uy; 0xe3uy; 0xb4uy; 0x91uy; 0x37uy; 0x9auy; 0x97uy; 0x86uy; 0x99uy; 0xd5uy; 0x09uy; 0xc5uy; 0xbbuy; 0xa3uy; 0x3fuy; 0x21uy; 0x29uy; 0x82uy; 0x14uy; 0x5cuy; 0xabuy; 0x25uy; 0xfbuy; 0xf2uy; 0x4fuy; 0x58uy; 0x26uy; 0xd4uy; 0x83uy; 0xaauy; 0x66uy; 0x89uy; 0x67uy; 0x7euy; 0xc0uy; 0x49uy; 0xe1uy; 0x11uy; 0x10uy; 0x7fuy; 0x7auy; 0xdauy; 0x29uy; 0x04uy; 0xffuy; 0xf0uy; 0xcbuy; 0x09uy; 0x7cuy; 0x9duy; 0xfauy; 0x03uy; 0x6fuy; 0x81uy; 0x09uy; 0x31uy; 0x60uy; 0xfbuy; 0x08uy; 0xfauy; 0x74uy; 0xd3uy; 0x64uy; 0x44uy; 0x7cuy; 0x55uy; 0x85uy; 0xecuy; 0x9cuy; 0x6euy; 0x25uy; 0xb7uy; 0x6cuy; 0xc5uy; 0x37uy; 0xb6uy; 0x83uy; 0x87uy; 0x72uy; 0x95uy; 0x8buy; 0x9duy; 0xe1uy; 0x69uy; 0x5cuy; 0x31uy; 0x95uy; 0x42uy; 0xa6uy; 0x2cuy; 0xd1uy; 0x36uy; 0x47uy; 0x1fuy; 0xecuy; 0x54uy; 0xabuy; 0xa2uy; 0x1cuy; 0xd8uy; 0x00uy; 0xccuy; 0xbcuy; 0x0duy; 0x65uy; 0xe2uy; 0x67uy; 0xbfuy; 0xbcuy; 0xeauy; 0xeeuy; 0x9euy; 0xe4uy; 0x36uy; 0x95uy; 0xbeuy; 0x73uy; 0xd9uy; 0xa6uy; 0xd9uy; 0x0fuy; 0xa0uy; 0xccuy; 0x82uy; 0x76uy; 0x26uy; 0xaduy; 0x5buy; 0x58uy; 0x6cuy; 0x4euy; 0xabuy; 0x29uy; 0x64uy; 0xd3uy; 0xd9uy; 0xa9uy; 0x08uy; 0x8cuy; 0x1duy; 0xa1uy; 0x4fuy; 0x80uy; 0xd8uy; 0x3fuy; 0x94uy; 0xfbuy; 0xd3uy; 0x7buy; 0xfcuy; 0xd1uy; 0x2buy; 0xc3uy; 0x21uy; 0xebuy; 0xe5uy; 0x1cuy; 0x84uy; 0x23uy; 0x7fuy; 0x4buy; 0xfauy; 0xdbuy; 0x34uy; 0x18uy; 0xa2uy; 0xc2uy; 0xe5uy; 0x13uy; 0xfeuy; 0x6cuy; 0x49uy; 0x81uy; 0xd2uy; 0x73uy; 0xe7uy; 0xe2uy; 0xd7uy; 0xe4uy; 0x4fuy; 0x4buy; 0x08uy; 0x6euy; 0xb1uy; 0x12uy; 0x22uy; 0x10uy; 0x9duy; 0xacuy; 0x51uy; 0x1euy; 0x17uy; 0xd9uy; 0x8auy; 0x0buy; 0x42uy; 0x88uy; 0x16uy; 0x81uy; 0x37uy; 0x7cuy; 0x6auy; 0xf7uy; 0xefuy; 0x2duy; 0xe3uy; 0xd9uy; 0xf8uy; 0x5fuy; 0xe0uy; 0x53uy; 0x27uy; 0x74uy; 0xb9uy; 0xe2uy; 0xd6uy; 0x1cuy; 0x80uy; 0x2cuy; 0x52uy; 0x65uy; ] in assert_norm (List.Tot.length l = 513); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) = 513ul let output8: (b: B.buffer UInt8.t { B.length b = 529 /\ B.recallable b }) = [@inline_let] let l = [ 0xfduy; 0x81uy; 0x8duy; 0xd0uy; 0x3duy; 0xb4uy; 0xd5uy; 0xdfuy; 0xd3uy; 0x42uy; 0x47uy; 0x5auy; 0x6duy; 0x19uy; 0x27uy; 0x66uy; 0x4buy; 0x2euy; 0x0cuy; 0x27uy; 0x9cuy; 0x96uy; 0x4cuy; 0x72uy; 0x02uy; 0xa3uy; 0x65uy; 0xc3uy; 0xb3uy; 0x6fuy; 0x2euy; 0xbduy; 0x63uy; 0x8auy; 0x4auy; 0x5duy; 0x29uy; 0xa2uy; 0xd0uy; 0x28uy; 0x48uy; 0xc5uy; 0x3duy; 0x98uy; 0xa3uy; 0xbcuy; 0xe0uy; 0xbeuy; 0x3buy; 0x3fuy; 0xe6uy; 0x8auy; 0xa4uy; 0x7fuy; 0x53uy; 0x06uy; 0xfauy; 0x7fuy; 0x27uy; 0x76uy; 0x72uy; 0x31uy; 0xa1uy; 0xf5uy; 0xd6uy; 0x0cuy; 0x52uy; 0x47uy; 0xbauy; 0xcduy; 0x4fuy; 0xd7uy; 0xebuy; 0x05uy; 0x48uy; 0x0duy; 0x7cuy; 0x35uy; 0x4auy; 0x09uy; 0xc9uy; 0x76uy; 0x71uy; 0x02uy; 0xa3uy; 0xfbuy; 0xb7uy; 0x1auy; 0x65uy; 0xb7uy; 0xeduy; 0x98uy; 0xc6uy; 0x30uy; 0x8auy; 0x00uy; 0xaeuy; 0xa1uy; 0x31uy; 0xe5uy; 0xb5uy; 0x9euy; 0x6duy; 0x62uy; 0xdauy; 0xdauy; 0x07uy; 0x0fuy; 0x38uy; 0x38uy; 0xd3uy; 0xcbuy; 0xc1uy; 0xb0uy; 0xaduy; 0xecuy; 0x72uy; 0xecuy; 0xb1uy; 0xa2uy; 0x7buy; 0x59uy; 0xf3uy; 0x3duy; 0x2buy; 0xefuy; 0xcduy; 0x28uy; 0x5buy; 0x83uy; 0xccuy; 0x18uy; 0x91uy; 0x88uy; 0xb0uy; 0x2euy; 0xf9uy; 0x29uy; 0x31uy; 0x18uy; 0xf9uy; 0x4euy; 0xe9uy; 0x0auy; 0x91uy; 0x92uy; 0x9fuy; 0xaeuy; 0x2duy; 0xaduy; 0xf4uy; 0xe6uy; 0x1auy; 0xe2uy; 0xa4uy; 0xeeuy; 0x47uy; 0x15uy; 0xbfuy; 0x83uy; 0x6euy; 0xd7uy; 0x72uy; 0x12uy; 0x3buy; 0x2duy; 0x24uy; 0xe9uy; 0xb2uy; 0x55uy; 0xcbuy; 0x3cuy; 0x10uy; 0xf0uy; 0x24uy; 0x8auy; 0x4auy; 0x02uy; 0xeauy; 0x90uy; 0x25uy; 0xf0uy; 0xb4uy; 0x79uy; 0x3auy; 0xefuy; 0x6euy; 0xf5uy; 0x52uy; 0xdfuy; 0xb0uy; 0x0auy; 0xcduy; 0x24uy; 0x1cuy; 0xd3uy; 0x2euy; 0x22uy; 0x74uy; 0xeauy; 0x21uy; 0x6fuy; 0xe9uy; 0xbduy; 0xc8uy; 0x3euy; 0x36uy; 0x5buy; 0x19uy; 0xf1uy; 0xcauy; 0x99uy; 0x0auy; 0xb4uy; 0xa7uy; 0x52uy; 0x1auy; 0x4euy; 0xf2uy; 0xaduy; 0x8duy; 0x56uy; 0x85uy; 0xbbuy; 0x64uy; 0x89uy; 0xbauy; 0x26uy; 0xf9uy; 0xc7uy; 0xe1uy; 0x89uy; 0x19uy; 0x22uy; 0x77uy; 0xc3uy; 0xa8uy; 0xfcuy; 0xffuy; 0xaduy; 0xfeuy; 0xb9uy; 0x48uy; 0xaeuy; 0x12uy; 0x30uy; 0x9fuy; 0x19uy; 0xfbuy; 0x1buy; 0xefuy; 0x14uy; 0x87uy; 0x8auy; 0x78uy; 0x71uy; 0xf3uy; 0xf4uy; 0xb7uy; 0x00uy; 0x9cuy; 0x1duy; 0xb5uy; 0x3duy; 0x49uy; 0x00uy; 0x0cuy; 0x06uy; 0xd4uy; 0x50uy; 0xf9uy; 0x54uy; 0x45uy; 0xb2uy; 0x5buy; 0x43uy; 0xdbuy; 0x6duy; 0xcfuy; 0x1auy; 0xe9uy; 0x7auy; 0x7auy; 0xcfuy; 0xfcuy; 0x8auy; 0x4euy; 0x4duy; 0x0buy; 0x07uy; 0x63uy; 0x28uy; 0xd8uy; 0xe7uy; 0x08uy; 0x95uy; 0xdfuy; 0xa6uy; 0x72uy; 0x93uy; 0x2euy; 0xbbuy; 0xa0uy; 0x42uy; 0x89uy; 0x16uy; 0xf1uy; 0xd9uy; 0x0cuy; 0xf9uy; 0xa1uy; 0x16uy; 0xfduy; 0xd9uy; 0x03uy; 0xb4uy; 0x3buy; 0x8auy; 0xf5uy; 0xf6uy; 0xe7uy; 0x6buy; 0x2euy; 0x8euy; 0x4cuy; 0x3duy; 0xe2uy; 0xafuy; 0x08uy; 0x45uy; 0x03uy; 0xffuy; 0x09uy; 0xb6uy; 0xebuy; 0x2duy; 0xc6uy; 0x1buy; 0x88uy; 0x94uy; 0xacuy; 0x3euy; 0xf1uy; 0x9fuy; 0x0euy; 0x0euy; 0x2buy; 0xd5uy; 0x00uy; 0x4duy; 0x3fuy; 0x3buy; 0x53uy; 0xaeuy; 0xafuy; 0x1cuy; 0x33uy; 0x5fuy; 0x55uy; 0x6euy; 0x8duy; 0xafuy; 0x05uy; 0x7auy; 0x10uy; 0x34uy; 0xc9uy; 0xf4uy; 0x66uy; 0xcbuy; 0x62uy; 0x12uy; 0xa6uy; 0xeeuy; 0xe8uy; 0x1cuy; 0x5duy; 0x12uy; 0x86uy; 0xdbuy; 0x6fuy; 0x1cuy; 0x33uy; 0xc4uy; 0x1cuy; 0xdauy; 0x82uy; 0x2duy; 0x3buy; 0x59uy; 0xfeuy; 0xb1uy; 0xa4uy; 0x59uy; 0x41uy; 0x86uy; 0xd0uy; 0xefuy; 0xaeuy; 0xfbuy; 0xdauy; 0x6duy; 0x11uy; 0xb8uy; 0xcauy; 0xe9uy; 0x6euy; 0xffuy; 0xf7uy; 0xa9uy; 0xd9uy; 0x70uy; 0x30uy; 0xfcuy; 0x53uy; 0xe2uy; 0xd7uy; 0xa2uy; 0x4euy; 0xc7uy; 0x91uy; 0xd9uy; 0x07uy; 0x06uy; 0xaauy; 0xdduy; 0xb0uy; 0x59uy; 0x28uy; 0x1duy; 0x00uy; 0x66uy; 0xc5uy; 0x54uy; 0xc2uy; 0xfcuy; 0x06uy; 0xdauy; 0x05uy; 0x90uy; 0x52uy; 0x1duy; 0x37uy; 0x66uy; 0xeeuy; 0xf0uy; 0xb2uy; 0x55uy; 0x8auy; 0x5duy; 0xd2uy; 0x38uy; 0x86uy; 0x94uy; 0x9buy; 0xfcuy; 0x10uy; 0x4cuy; 0xa1uy; 0xb9uy; 0x64uy; 0x3euy; 0x44uy; 0xb8uy; 0x5fuy; 0xb0uy; 0x0cuy; 0xecuy; 0xe0uy; 0xc9uy; 0xe5uy; 0x62uy; 0x75uy; 0x3fuy; 0x09uy; 0xd5uy; 0xf5uy; 0xd9uy; 0x26uy; 0xbauy; 0x9euy; 0xd2uy; 0xf4uy; 0xb9uy; 0x48uy; 0x0auy; 0xbcuy; 0xa2uy; 0xd6uy; 0x7cuy; 0x36uy; 0x11uy; 0x7duy; 0x26uy; 0x81uy; 0x89uy; 0xcfuy; 0xa4uy; 0xaduy; 0x73uy; 0x0euy; 0xeeuy; 0xccuy; 0x06uy; 0xa9uy; 0xdbuy; 0xb1uy; 0xfduy; 0xfbuy; 0x09uy; 0x7fuy; 0x90uy; 0x42uy; 0x37uy; 0x2fuy; 0xe1uy; 0x9cuy; 0x0fuy; 0x6fuy; 0xcfuy; 0x43uy; 0xb5uy; 0xd9uy; 0x90uy; 0xe1uy; 0x85uy; 0xf5uy; 0xa8uy; 0xaeuy; ] in assert_norm (List.Tot.length l = 529); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output8_len: (x:UInt32.t { UInt32.v x = B.length output8 }) = 529ul let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x47uy; 0x11uy; 0xebuy; 0x86uy; 0x2buy; 0x2cuy; 0xabuy; 0x44uy; 0x34uy; 0xdauy; 0x7fuy; 0x57uy; 0x03uy; 0x39uy; 0x0cuy; 0xafuy; 0x2cuy; 0x14uy; 0xfduy; 0x65uy; 0x23uy; 0xe9uy; 0x8euy; 0x74uy; 0xd5uy; 0x08uy; 0x68uy; 0x08uy; 0xe7uy; 0xb4uy; 0x72uy; 0xd7uy; ] 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 nonce9: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdbuy; 0x92uy; 0x0fuy; 0x7fuy; 0x17uy; 0x54uy; 0x0cuy; 0x30uy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce9_len: (x:UInt32.t { UInt32.v x = B.length nonce9 }) = 12ul let aad9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) = [@inline_let] let l = [ 0xd2uy; 0xa1uy; 0x70uy; 0xdbuy; 0x7auy; 0xf8uy; 0xfauy; 0x27uy; 0xbauy; 0x73uy; 0x0fuy; 0xbfuy; 0x3duy; 0x1euy; 0x82uy; 0xb2uy; ] in assert_norm (List.Tot.length l = 16); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad9_len: (x:UInt32.t { UInt32.v x = B.length aad9 }) = 16ul let input9: (b: B.buffer UInt8.t { B.length b = 1024 /\ B.recallable b /\ B.disjoint b aad9 }) = B.recall aad9;[@inline_let] let l = [ 0x42uy; 0x93uy; 0xe4uy; 0xebuy; 0x97uy; 0xb0uy; 0x57uy; 0xbfuy; 0x1auy; 0x8buy; 0x1fuy; 0xe4uy; 0x5fuy; 0x36uy; 0x20uy; 0x3cuy; 0xefuy; 0x0auy; 0xa9uy; 0x48uy; 0x5fuy; 0x5fuy; 0x37uy; 0x22uy; 0x3auy; 0xdeuy; 0xe3uy; 0xaeuy; 0xbeuy; 0xaduy; 0x07uy; 0xccuy; 0xb1uy; 0xf6uy; 0xf5uy; 0xf9uy; 0x56uy; 0xdduy; 0xe7uy; 0x16uy; 0x1euy; 0x7fuy; 0xdfuy; 0x7auy; 0x9euy; 0x75uy; 0xb7uy; 0xc7uy; 0xbeuy; 0xbeuy; 0x8auy; 0x36uy; 0x04uy; 0xc0uy; 0x10uy; 0xf4uy; 0x95uy; 0x20uy; 0x03uy; 0xecuy; 0xdcuy; 0x05uy; 0xa1uy; 0x7duy; 0xc4uy; 0xa9uy; 0x2cuy; 0x82uy; 0xd0uy; 0xbcuy; 0x8buy; 0xc5uy; 0xc7uy; 0x45uy; 0x50uy; 0xf6uy; 0xa2uy; 0x1auy; 0xb5uy; 0x46uy; 0x3buy; 0x73uy; 0x02uy; 0xa6uy; 0x83uy; 0x4buy; 0x73uy; 0x82uy; 0x58uy; 0x5euy; 0x3buy; 0x65uy; 0x2fuy; 0x0euy; 0xfduy; 0x2buy; 0x59uy; 0x16uy; 0xceuy; 0xa1uy; 0x60uy; 0x9cuy; 0xe8uy; 0x3auy; 0x99uy; 0xeduy; 0x8duy; 0x5auy; 0xcfuy; 0xf6uy; 0x83uy; 0xafuy; 0xbauy; 0xd7uy; 0x73uy; 0x73uy; 0x40uy; 0x97uy; 0x3duy; 0xcauy; 0xefuy; 0x07uy; 0x57uy; 0xe6uy; 0xd9uy; 0x70uy; 0x0euy; 0x95uy; 0xaeuy; 0xa6uy; 0x8duy; 0x04uy; 0xccuy; 0xeeuy; 0xf7uy; 0x09uy; 0x31uy; 0x77uy; 0x12uy; 0xa3uy; 0x23uy; 0x97uy; 0x62uy; 0xb3uy; 0x7buy; 0x32uy; 0xfbuy; 0x80uy; 0x14uy; 0x48uy; 0x81uy; 0xc3uy; 0xe5uy; 0xeauy; 0x91uy; 0x39uy; 0x52uy; 0x81uy; 0xa2uy; 0x4fuy; 0xe4uy; 0xb3uy; 0x09uy; 0xffuy; 0xdeuy; 0x5euy; 0xe9uy; 0x58uy; 0x84uy; 0x6euy; 0xf9uy; 0x3duy; 0xdfuy; 0x25uy; 0xeauy; 0xaduy; 0xaeuy; 0xe6uy; 0x9auy; 0xd1uy; 0x89uy; 0x55uy; 0xd3uy; 0xdeuy; 0x6cuy; 0x52uy; 0xdbuy; 0x70uy; 0xfeuy; 0x37uy; 0xceuy; 0x44uy; 0x0auy; 0xa8uy; 0x25uy; 0x5fuy; 0x92uy; 0xc1uy; 0x33uy; 0x4auy; 0x4fuy; 0x9buy; 0x62uy; 0x35uy; 0xffuy; 0xceuy; 0xc0uy; 0xa9uy; 0x60uy; 0xceuy; 0x52uy; 0x00uy; 0x97uy; 0x51uy; 0x35uy; 0x26uy; 0x2euy; 0xb9uy; 0x36uy; 0xa9uy; 0x87uy; 0x6euy; 0x1euy; 0xccuy; 0x91uy; 0x78uy; 0x53uy; 0x98uy; 0x86uy; 0x5buy; 0x9cuy; 0x74uy; 0x7duy; 0x88uy; 0x33uy; 0xe1uy; 0xdfuy; 0x37uy; 0x69uy; 0x2buy; 0xbbuy; 0xf1uy; 0x4duy; 0xf4uy; 0xd1uy; 0xf1uy; 0x39uy; 0x93uy; 0x17uy; 0x51uy; 0x19uy; 0xe3uy; 0x19uy; 0x1euy; 0x76uy; 0x37uy; 0x25uy; 0xfbuy; 0x09uy; 0x27uy; 0x6auy; 0xabuy; 0x67uy; 0x6fuy; 0x14uy; 0x12uy; 0x64uy; 0xe7uy; 0xc4uy; 0x07uy; 0xdfuy; 0x4duy; 0x17uy; 0xbbuy; 0x6duy; 0xe0uy; 0xe9uy; 0xb9uy; 0xabuy; 0xcauy; 0x10uy; 0x68uy; 0xafuy; 0x7euy; 0xb7uy; 0x33uy; 0x54uy; 0x73uy; 0x07uy; 0x6euy; 0xf7uy; 0x81uy; 0x97uy; 0x9cuy; 0x05uy; 0x6fuy; 0x84uy; 0x5fuy; 0xd2uy; 0x42uy; 0xfbuy; 0x38uy; 0xcfuy; 0xd1uy; 0x2fuy; 0x14uy; 0x30uy; 0x88uy; 0x98uy; 0x4duy; 0x5auy; 0xa9uy; 0x76uy; 0xd5uy; 0x4fuy; 0x3euy; 0x70uy; 0x6cuy; 0x85uy; 0x76uy; 0xd7uy; 0x01uy; 0xa0uy; 0x1auy; 0xc8uy; 0x4euy; 0xaauy; 0xacuy; 0x78uy; 0xfeuy; 0x46uy; 0xdeuy; 0x6auy; 0x05uy; 0x46uy; 0xa7uy; 0x43uy; 0x0cuy; 0xb9uy; 0xdeuy; 0xb9uy; 0x68uy; 0xfbuy; 0xceuy; 0x42uy; 0x99uy; 0x07uy; 0x4duy; 0x0buy; 0x3buy; 0x5auy; 0x30uy; 0x35uy; 0xa8uy; 0xf9uy; 0x3auy; 0x73uy; 0xefuy; 0x0fuy; 0xdbuy; 0x1euy; 0x16uy; 0x42uy; 0xc4uy; 0xbauy; 0xaeuy; 0x58uy; 0xaauy; 0xf8uy; 0xe5uy; 0x75uy; 0x2fuy; 0x1buy; 0x15uy; 0x5cuy; 0xfduy; 0x0auy; 0x97uy; 0xd0uy; 0xe4uy; 0x37uy; 0x83uy; 0x61uy; 0x5fuy; 0x43uy; 0xa6uy; 0xc7uy; 0x3fuy; 0x38uy; 0x59uy; 0xe6uy; 0xebuy; 0xa3uy; 0x90uy; 0xc3uy; 0xaauy; 0xaauy; 0x5auy; 0xd3uy; 0x34uy; 0xd4uy; 0x17uy; 0xc8uy; 0x65uy; 0x3euy; 0x57uy; 0xbcuy; 0x5euy; 0xdduy; 0x9euy; 0xb7uy; 0xf0uy; 0x2euy; 0x5buy; 0xb2uy; 0x1fuy; 0x8auy; 0x08uy; 0x0duy; 0x45uy; 0x91uy; 0x0buy; 0x29uy; 0x53uy; 0x4fuy; 0x4cuy; 0x5auy; 0x73uy; 0x56uy; 0xfeuy; 0xafuy; 0x41uy; 0x01uy; 0x39uy; 0x0auy; 0x24uy; 0x3cuy; 0x7euy; 0xbeuy; 0x4euy; 0x53uy; 0xf3uy; 0xebuy; 0x06uy; 0x66uy; 0x51uy; 0x28uy; 0x1duy; 0xbduy; 0x41uy; 0x0auy; 0x01uy; 0xabuy; 0x16uy; 0x47uy; 0x27uy; 0x47uy; 0x47uy; 0xf7uy; 0xcbuy; 0x46uy; 0x0auy; 0x70uy; 0x9euy; 0x01uy; 0x9cuy; 0x09uy; 0xe1uy; 0x2auy; 0x00uy; 0x1auy; 0xd8uy; 0xd4uy; 0x79uy; 0x9duy; 0x80uy; 0x15uy; 0x8euy; 0x53uy; 0x2auy; 0x65uy; 0x83uy; 0x78uy; 0x3euy; 0x03uy; 0x00uy; 0x07uy; 0x12uy; 0x1fuy; 0x33uy; 0x3euy; 0x7buy; 0x13uy; 0x37uy; 0xf1uy; 0xc3uy; 0xefuy; 0xb7uy; 0xc1uy; 0x20uy; 0x3cuy; 0x3euy; 0x67uy; 0x66uy; 0x5duy; 0x88uy; 0xa7uy; 0x7duy; 0x33uy; 0x50uy; 0x77uy; 0xb0uy; 0x28uy; 0x8euy; 0xe7uy; 0x2cuy; 0x2euy; 0x7auy; 0xf4uy; 0x3cuy; 0x8duy; 0x74uy; 0x83uy; 0xafuy; 0x8euy; 0x87uy; 0x0fuy; 0xe4uy; 0x50uy; 0xffuy; 0x84uy; 0x5cuy; 0x47uy; 0x0cuy; 0x6auy; 0x49uy; 0xbfuy; 0x42uy; 0x86uy; 0x77uy; 0x15uy; 0x48uy; 0xa5uy; 0x90uy; 0x5duy; 0x93uy; 0xd6uy; 0x2auy; 0x11uy; 0xd5uy; 0xd5uy; 0x11uy; 0xaauy; 0xceuy; 0xe7uy; 0x6fuy; 0xa5uy; 0xb0uy; 0x09uy; 0x2cuy; 0x8duy; 0xd3uy; 0x92uy; 0xf0uy; 0x5auy; 0x2auy; 0xdauy; 0x5buy; 0x1euy; 0xd5uy; 0x9auy; 0xc4uy; 0xc4uy; 0xf3uy; 0x49uy; 0x74uy; 0x41uy; 0xcauy; 0xe8uy; 0xc1uy; 0xf8uy; 0x44uy; 0xd6uy; 0x3cuy; 0xaeuy; 0x6cuy; 0x1duy; 0x9auy; 0x30uy; 0x04uy; 0x4duy; 0x27uy; 0x0euy; 0xb1uy; 0x5fuy; 0x59uy; 0xa2uy; 0x24uy; 0xe8uy; 0xe1uy; 0x98uy; 0xc5uy; 0x6auy; 0x4cuy; 0xfeuy; 0x41uy; 0xd2uy; 0x27uy; 0x42uy; 0x52uy; 0xe1uy; 0xe9uy; 0x7duy; 0x62uy; 0xe4uy; 0x88uy; 0x0fuy; 0xaduy; 0xb2uy; 0x70uy; 0xcbuy; 0x9duy; 0x4cuy; 0x27uy; 0x2euy; 0x76uy; 0x1euy; 0x1auy; 0x63uy; 0x65uy; 0xf5uy; 0x3buy; 0xf8uy; 0x57uy; 0x69uy; 0xebuy; 0x5buy; 0x38uy; 0x26uy; 0x39uy; 0x33uy; 0x25uy; 0x45uy; 0x3euy; 0x91uy; 0xb8uy; 0xd8uy; 0xc7uy; 0xd5uy; 0x42uy; 0xc0uy; 0x22uy; 0x31uy; 0x74uy; 0xf4uy; 0xbcuy; 0x0cuy; 0x23uy; 0xf1uy; 0xcauy; 0xc1uy; 0x8duy; 0xd7uy; 0xbeuy; 0xc9uy; 0x62uy; 0xe4uy; 0x08uy; 0x1auy; 0xcfuy; 0x36uy; 0xd5uy; 0xfeuy; 0x55uy; 0x21uy; 0x59uy; 0x91uy; 0x87uy; 0x87uy; 0xdfuy; 0x06uy; 0xdbuy; 0xdfuy; 0x96uy; 0x45uy; 0x58uy; 0xdauy; 0x05uy; 0xcduy; 0x50uy; 0x4duy; 0xd2uy; 0x7duy; 0x05uy; 0x18uy; 0x73uy; 0x6auy; 0x8duy; 0x11uy; 0x85uy; 0xa6uy; 0x88uy; 0xe8uy; 0xdauy; 0xe6uy; 0x30uy; 0x33uy; 0xa4uy; 0x89uy; 0x31uy; 0x75uy; 0xbeuy; 0x69uy; 0x43uy; 0x84uy; 0x43uy; 0x50uy; 0x87uy; 0xdduy; 0x71uy; 0x36uy; 0x83uy; 0xc3uy; 0x78uy; 0x74uy; 0x24uy; 0x0auy; 0xeduy; 0x7buy; 0xdbuy; 0xa4uy; 0x24uy; 0x0buy; 0xb9uy; 0x7euy; 0x5duy; 0xffuy; 0xdeuy; 0xb1uy; 0xefuy; 0x61uy; 0x5auy; 0x45uy; 0x33uy; 0xf6uy; 0x17uy; 0x07uy; 0x08uy; 0x98uy; 0x83uy; 0x92uy; 0x0fuy; 0x23uy; 0x6duy; 0xe6uy; 0xaauy; 0x17uy; 0x54uy; 0xaduy; 0x6auy; 0xc8uy; 0xdbuy; 0x26uy; 0xbeuy; 0xb8uy; 0xb6uy; 0x08uy; 0xfauy; 0x68uy; 0xf1uy; 0xd7uy; 0x79uy; 0x6fuy; 0x18uy; 0xb4uy; 0x9euy; 0x2duy; 0x3fuy; 0x1buy; 0x64uy; 0xafuy; 0x8duy; 0x06uy; 0x0euy; 0x49uy; 0x28uy; 0xe0uy; 0x5duy; 0x45uy; 0x68uy; 0x13uy; 0x87uy; 0xfauy; 0xdeuy; 0x40uy; 0x7buy; 0xd2uy; 0xc3uy; 0x94uy; 0xd5uy; 0xe1uy; 0xd9uy; 0xc2uy; 0xafuy; 0x55uy; 0x89uy; 0xebuy; 0xb4uy; 0x12uy; 0x59uy; 0xa8uy; 0xd4uy; 0xc5uy; 0x29uy; 0x66uy; 0x38uy; 0xe6uy; 0xacuy; 0x22uy; 0x22uy; 0xd9uy; 0x64uy; 0x9buy; 0x34uy; 0x0auy; 0x32uy; 0x9fuy; 0xc2uy; 0xbfuy; 0x17uy; 0x6cuy; 0x3fuy; 0x71uy; 0x7auy; 0x38uy; 0x6buy; 0x98uy; 0xfbuy; 0x49uy; 0x36uy; 0x89uy; 0xc9uy; 0xe2uy; 0xd6uy; 0xc7uy; 0x5duy; 0xd0uy; 0x69uy; 0x5fuy; 0x23uy; 0x35uy; 0xc9uy; 0x30uy; 0xe2uy; 0xfduy; 0x44uy; 0x58uy; 0x39uy; 0xd7uy; 0x97uy; 0xfbuy; 0x5cuy; 0x00uy; 0xd5uy; 0x4fuy; 0x7auy; 0x1auy; 0x95uy; 0x8buy; 0x62uy; 0x4buy; 0xceuy; 0xe5uy; 0x91uy; 0x21uy; 0x7buy; 0x30uy; 0x00uy; 0xd6uy; 0xdduy; 0x6duy; 0x02uy; 0x86uy; 0x49uy; 0x0fuy; 0x3cuy; 0x1auy; 0x27uy; 0x3cuy; 0xd3uy; 0x0euy; 0x71uy; 0xf2uy; 0xffuy; 0xf5uy; 0x2fuy; 0x87uy; 0xacuy; 0x67uy; 0x59uy; 0x81uy; 0xa3uy; 0xf7uy; 0xf8uy; 0xd6uy; 0x11uy; 0x0cuy; 0x84uy; 0xa9uy; 0x03uy; 0xeeuy; 0x2auy; 0xc4uy; 0xf3uy; 0x22uy; 0xabuy; 0x7cuy; 0xe2uy; 0x25uy; 0xf5uy; 0x67uy; 0xa3uy; 0xe4uy; 0x11uy; 0xe0uy; 0x59uy; 0xb3uy; 0xcauy; 0x87uy; 0xa0uy; 0xaeuy; 0xc9uy; 0xa6uy; 0x62uy; 0x1buy; 0x6euy; 0x4duy; 0x02uy; 0x6buy; 0x07uy; 0x9duy; 0xfduy; 0xd0uy; 0x92uy; 0x06uy; 0xe1uy; 0xb2uy; 0x9auy; 0x4auy; 0x1fuy; 0x1fuy; 0x13uy; 0x49uy; 0x99uy; 0x97uy; 0x08uy; 0xdeuy; 0x7fuy; 0x98uy; 0xafuy; 0x51uy; 0x98uy; 0xeeuy; 0x2cuy; 0xcbuy; 0xf0uy; 0x0buy; 0xc6uy; 0xb6uy; 0xb7uy; 0x2duy; 0x9auy; 0xb1uy; 0xacuy; 0xa6uy; 0xe3uy; 0x15uy; 0x77uy; 0x9duy; 0x6buy; 0x1auy; 0xe4uy; 0xfcuy; 0x8buy; 0xf2uy; 0x17uy; 0x59uy; 0x08uy; 0x04uy; 0x58uy; 0x81uy; 0x9duy; 0x1buy; 0x1buy; 0x69uy; 0x55uy; 0xc2uy; 0xb4uy; 0x3cuy; 0x1fuy; 0x50uy; 0xf1uy; 0x7fuy; 0x77uy; 0x90uy; 0x4cuy; 0x66uy; 0x40uy; 0x5auy; 0xc0uy; 0x33uy; 0x1fuy; 0xcbuy; 0x05uy; 0x6duy; 0x5cuy; 0x06uy; 0x87uy; 0x52uy; 0xa2uy; 0x8fuy; 0x26uy; 0xd5uy; 0x4fuy; ] in assert_norm (List.Tot.length l = 1024); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) = 1024ul let output9: (b: B.buffer UInt8.t { B.length b = 1040 /\ B.recallable b }) = [@inline_let] let l = [ 0xe5uy; 0x26uy; 0xa4uy; 0x3duy; 0xbduy; 0x33uy; 0xd0uy; 0x4buy; 0x6fuy; 0x05uy; 0xa7uy; 0x6euy; 0x12uy; 0x7auy; 0xd2uy; 0x74uy; 0xa6uy; 0xdduy; 0xbduy; 0x95uy; 0xebuy; 0xf9uy; 0xa4uy; 0xf1uy; 0x59uy; 0x93uy; 0x91uy; 0x70uy; 0xd9uy; 0xfeuy; 0x9auy; 0xcduy; 0x53uy; 0x1fuy; 0x3auy; 0xabuy; 0xa6uy; 0x7cuy; 0x9fuy; 0xa6uy; 0x9euy; 0xbduy; 0x99uy; 0xd9uy; 0xb5uy; 0x97uy; 0x44uy; 0xd5uy; 0x14uy; 0x48uy; 0x4duy; 0x9duy; 0xc0uy; 0xd0uy; 0x05uy; 0x96uy; 0xebuy; 0x4cuy; 0x78uy; 0x55uy; 0x09uy; 0x08uy; 0x01uy; 0x02uy; 0x30uy; 0x90uy; 0x7buy; 0x96uy; 0x7auy; 0x7buy; 0x5fuy; 0x30uy; 0x41uy; 0x24uy; 0xceuy; 0x68uy; 0x61uy; 0x49uy; 0x86uy; 0x57uy; 0x82uy; 0xdduy; 0x53uy; 0x1cuy; 0x51uy; 0x28uy; 0x2buy; 0x53uy; 0x6euy; 0x2duy; 0xc2uy; 0x20uy; 0x4cuy; 0xdduy; 0x8fuy; 0x65uy; 0x10uy; 0x20uy; 0x50uy; 0xdduy; 0x9duy; 0x50uy; 0xe5uy; 0x71uy; 0x40uy; 0x53uy; 0x69uy; 0xfcuy; 0x77uy; 0x48uy; 0x11uy; 0xb9uy; 0xdeuy; 0xa4uy; 0x8duy; 0x58uy; 0xe4uy; 0xa6uy; 0x1auy; 0x18uy; 0x47uy; 0x81uy; 0x7euy; 0xfcuy; 0xdduy; 0xf6uy; 0xefuy; 0xceuy; 0x2fuy; 0x43uy; 0x68uy; 0xd6uy; 0x06uy; 0xe2uy; 0x74uy; 0x6auy; 0xaduy; 0x90uy; 0xf5uy; 0x37uy; 0xf3uy; 0x3duy; 0x82uy; 0x69uy; 0x40uy; 0xe9uy; 0x6buy; 0xa7uy; 0x3duy; 0xa8uy; 0x1euy; 0xd2uy; 0x02uy; 0x7cuy; 0xb7uy; 0x9buy; 0xe4uy; 0xdauy; 0x8fuy; 0x95uy; 0x06uy; 0xc5uy; 0xdfuy; 0x73uy; 0xa3uy; 0x20uy; 0x9auy; 0x49uy; 0xdeuy; 0x9cuy; 0xbcuy; 0xeeuy; 0x14uy; 0x3fuy; 0x81uy; 0x5euy; 0xf8uy; 0x3buy; 0x59uy; 0x3cuy; 0xe1uy; 0x68uy; 0x12uy; 0x5auy; 0x3auy; 0x76uy; 0x3auy; 0x3fuy; 0xf7uy; 0x87uy; 0x33uy; 0x0auy; 0x01uy; 0xb8uy; 0xd4uy; 0xeduy; 0xb6uy; 0xbeuy; 0x94uy; 0x5euy; 0x70uy; 0x40uy; 0x56uy; 0x67uy; 0x1fuy; 0x50uy; 0x44uy; 0x19uy; 0xceuy; 0x82uy; 0x70uy; 0x10uy; 0x87uy; 0x13uy; 0x20uy; 0x0buy; 0x4cuy; 0x5auy; 0xb6uy; 0xf6uy; 0xa7uy; 0xaeuy; 0x81uy; 0x75uy; 0x01uy; 0x81uy; 0xe6uy; 0x4buy; 0x57uy; 0x7cuy; 0xdduy; 0x6duy; 0xf8uy; 0x1cuy; 0x29uy; 0x32uy; 0xf7uy; 0xdauy; 0x3cuy; 0x2duy; 0xf8uy; 0x9buy; 0x25uy; 0x6euy; 0x00uy; 0xb4uy; 0xf7uy; 0x2fuy; 0xf7uy; 0x04uy; 0xf7uy; 0xa1uy; 0x56uy; 0xacuy; 0x4fuy; 0x1auy; 0x64uy; 0xb8uy; 0x47uy; 0x55uy; 0x18uy; 0x7buy; 0x07uy; 0x4duy; 0xbduy; 0x47uy; 0x24uy; 0x80uy; 0x5duy; 0xa2uy; 0x70uy; 0xc5uy; 0xdduy; 0x8euy; 0x82uy; 0xd4uy; 0xebuy; 0xecuy; 0xb2uy; 0x0cuy; 0x39uy; 0xd2uy; 0x97uy; 0xc1uy; 0xcbuy; 0xebuy; 0xf4uy; 0x77uy; 0x59uy; 0xb4uy; 0x87uy; 0xefuy; 0xcbuy; 0x43uy; 0x2duy; 0x46uy; 0x54uy; 0xd1uy; 0xa7uy; 0xd7uy; 0x15uy; 0x99uy; 0x0auy; 0x43uy; 0xa1uy; 0xe0uy; 0x99uy; 0x33uy; 0x71uy; 0xc1uy; 0xeduy; 0xfeuy; 0x72uy; 0x46uy; 0x33uy; 0x8euy; 0x91uy; 0x08uy; 0x9fuy; 0xc8uy; 0x2euy; 0xcauy; 0xfauy; 0xdcuy; 0x59uy; 0xd5uy; 0xc3uy; 0x76uy; 0x84uy; 0x9fuy; 0xa3uy; 0x37uy; 0x68uy; 0xc3uy; 0xf0uy; 0x47uy; 0x2cuy; 0x68uy; 0xdbuy; 0x5euy; 0xc3uy; 0x49uy; 0x4cuy; 0xe8uy; 0x92uy; 0x85uy; 0xe2uy; 0x23uy; 0xd3uy; 0x3fuy; 0xaduy; 0x32uy; 0xe5uy; 0x2buy; 0x82uy; 0xd7uy; 0x8fuy; 0x99uy; 0x0auy; 0x59uy; 0x5cuy; 0x45uy; 0xd9uy; 0xb4uy; 0x51uy; 0x52uy; 0xc2uy; 0xaeuy; 0xbfuy; 0x80uy; 0xcfuy; 0xc9uy; 0xc9uy; 0x51uy; 0x24uy; 0x2auy; 0x3buy; 0x3auy; 0x4duy; 0xaeuy; 0xebuy; 0xbduy; 0x22uy; 0xc3uy; 0x0euy; 0x0fuy; 0x59uy; 0x25uy; 0x92uy; 0x17uy; 0xe9uy; 0x74uy; 0xc7uy; 0x8buy; 0x70uy; 0x70uy; 0x36uy; 0x55uy; 0x95uy; 0x75uy; 0x4buy; 0xaduy; 0x61uy; 0x2buy; 0x09uy; 0xbcuy; 0x82uy; 0xf2uy; 0x6euy; 0x94uy; 0x43uy; 0xaeuy; 0xc3uy; 0xd5uy; 0xcduy; 0x8euy; 0xfeuy; 0x5buy; 0x9auy; 0x88uy; 0x43uy; 0x01uy; 0x75uy; 0xb2uy; 0x23uy; 0x09uy; 0xf7uy; 0x89uy; 0x83uy; 0xe7uy; 0xfauy; 0xf9uy; 0xb4uy; 0x9buy; 0xf8uy; 0xefuy; 0xbduy; 0x1cuy; 0x92uy; 0xc1uy; 0xdauy; 0x7euy; 0xfeuy; 0x05uy; 0xbauy; 0x5auy; 0xcduy; 0x07uy; 0x6auy; 0x78uy; 0x9euy; 0x5duy; 0xfbuy; 0x11uy; 0x2fuy; 0x79uy; 0x38uy; 0xb6uy; 0xc2uy; 0x5buy; 0x6buy; 0x51uy; 0xb4uy; 0x71uy; 0xdduy; 0xf7uy; 0x2auy; 0xe4uy; 0xf4uy; 0x72uy; 0x76uy; 0xaduy; 0xc2uy; 0xdduy; 0x64uy; 0x5duy; 0x79uy; 0xb6uy; 0xf5uy; 0x7auy; 0x77uy; 0x20uy; 0x05uy; 0x3duy; 0x30uy; 0x06uy; 0xd4uy; 0x4cuy; 0x0auy; 0x2cuy; 0x98uy; 0x5auy; 0xb9uy; 0xd4uy; 0x98uy; 0xa9uy; 0x3fuy; 0xc6uy; 0x12uy; 0xeauy; 0x3buy; 0x4buy; 0xc5uy; 0x79uy; 0x64uy; 0x63uy; 0x6buy; 0x09uy; 0x54uy; 0x3buy; 0x14uy; 0x27uy; 0xbauy; 0x99uy; 0x80uy; 0xc8uy; 0x72uy; 0xa8uy; 0x12uy; 0x90uy; 0x29uy; 0xbauy; 0x40uy; 0x54uy; 0x97uy; 0x2buy; 0x7buy; 0xfeuy; 0xebuy; 0xcduy; 0x01uy; 0x05uy; 0x44uy; 0x72uy; 0xdbuy; 0x99uy; 0xe4uy; 0x61uy; 0xc9uy; 0x69uy; 0xd6uy; 0xb9uy; 0x28uy; 0xd1uy; 0x05uy; 0x3euy; 0xf9uy; 0x0buy; 0x49uy; 0x0auy; 0x49uy; 0xe9uy; 0x8duy; 0x0euy; 0xa7uy; 0x4auy; 0x0fuy; 0xafuy; 0x32uy; 0xd0uy; 0xe0uy; 0xb2uy; 0x3auy; 0x55uy; 0x58uy; 0xfeuy; 0x5cuy; 0x28uy; 0x70uy; 0x51uy; 0x23uy; 0xb0uy; 0x7buy; 0x6auy; 0x5fuy; 0x1euy; 0xb8uy; 0x17uy; 0xd7uy; 0x94uy; 0x15uy; 0x8fuy; 0xeeuy; 0x20uy; 0xc7uy; 0x42uy; 0x25uy; 0x3euy; 0x9auy; 0x14uy; 0xd7uy; 0x60uy; 0x72uy; 0x39uy; 0x47uy; 0x48uy; 0xa9uy; 0xfeuy; 0xdduy; 0x47uy; 0x0auy; 0xb1uy; 0xe6uy; 0x60uy; 0x28uy; 0x8cuy; 0x11uy; 0x68uy; 0xe1uy; 0xffuy; 0xd7uy; 0xceuy; 0xc8uy; 0xbeuy; 0xb3uy; 0xfeuy; 0x27uy; 0x30uy; 0x09uy; 0x70uy; 0xd7uy; 0xfauy; 0x02uy; 0x33uy; 0x3auy; 0x61uy; 0x2euy; 0xc7uy; 0xffuy; 0xa4uy; 0x2auy; 0xa8uy; 0x6euy; 0xb4uy; 0x79uy; 0x35uy; 0x6duy; 0x4cuy; 0x1euy; 0x38uy; 0xf8uy; 0xeeuy; 0xd4uy; 0x84uy; 0x4euy; 0x6euy; 0x28uy; 0xa7uy; 0xceuy; 0xc8uy; 0xc1uy; 0xcfuy; 0x80uy; 0x05uy; 0xf3uy; 0x04uy; 0xefuy; 0xc8uy; 0x18uy; 0x28uy; 0x2euy; 0x8duy; 0x5euy; 0x0cuy; 0xdfuy; 0xb8uy; 0x5fuy; 0x96uy; 0xe8uy; 0xc6uy; 0x9cuy; 0x2fuy; 0xe5uy; 0xa6uy; 0x44uy; 0xd7uy; 0xe7uy; 0x99uy; 0x44uy; 0x0cuy; 0xecuy; 0xd7uy; 0x05uy; 0x60uy; 0x97uy; 0xbbuy; 0x74uy; 0x77uy; 0x58uy; 0xd5uy; 0xbbuy; 0x48uy; 0xdeuy; 0x5auy; 0xb2uy; 0x54uy; 0x7fuy; 0x0euy; 0x46uy; 0x70uy; 0x6auy; 0x6fuy; 0x78uy; 0xa5uy; 0x08uy; 0x89uy; 0x05uy; 0x4euy; 0x7euy; 0xa0uy; 0x69uy; 0xb4uy; 0x40uy; 0x60uy; 0x55uy; 0x77uy; 0x75uy; 0x9buy; 0x19uy; 0xf2uy; 0xd5uy; 0x13uy; 0x80uy; 0x77uy; 0xf9uy; 0x4buy; 0x3fuy; 0x1euy; 0xeeuy; 0xe6uy; 0x76uy; 0x84uy; 0x7buy; 0x8cuy; 0xe5uy; 0x27uy; 0xa8uy; 0x0auy; 0x91uy; 0x01uy; 0x68uy; 0x71uy; 0x8auy; 0x3fuy; 0x06uy; 0xabuy; 0xf6uy; 0xa9uy; 0xa5uy; 0xe6uy; 0x72uy; 0x92uy; 0xe4uy; 0x67uy; 0xe2uy; 0xa2uy; 0x46uy; 0x35uy; 0x84uy; 0x55uy; 0x7duy; 0xcauy; 0xa8uy; 0x85uy; 0xd0uy; 0xf1uy; 0x3fuy; 0xbeuy; 0xd7uy; 0x34uy; 0x64uy; 0xfcuy; 0xaeuy; 0xe3uy; 0xe4uy; 0x04uy; 0x9fuy; 0x66uy; 0x02uy; 0xb9uy; 0x88uy; 0x10uy; 0xd9uy; 0xc4uy; 0x4cuy; 0x31uy; 0x43uy; 0x7auy; 0x93uy; 0xe2uy; 0x9buy; 0x56uy; 0x43uy; 0x84uy; 0xdcuy; 0xdcuy; 0xdeuy; 0x1duy; 0xa4uy; 0x02uy; 0x0euy; 0xc2uy; 0xefuy; 0xc3uy; 0xf8uy; 0x78uy; 0xd1uy; 0xb2uy; 0x6buy; 0x63uy; 0x18uy; 0xc9uy; 0xa9uy; 0xe5uy; 0x72uy; 0xd8uy; 0xf3uy; 0xb9uy; 0xd1uy; 0x8auy; 0xc7uy; 0x1auy; 0x02uy; 0x27uy; 0x20uy; 0x77uy; 0x10uy; 0xe5uy; 0xc8uy; 0xd4uy; 0x4auy; 0x47uy; 0xe5uy; 0xdfuy; 0x5fuy; 0x01uy; 0xaauy; 0xb0uy; 0xd4uy; 0x10uy; 0xbbuy; 0x69uy; 0xe3uy; 0x36uy; 0xc8uy; 0xe1uy; 0x3duy; 0x43uy; 0xfbuy; 0x86uy; 0xcduy; 0xccuy; 0xbfuy; 0xf4uy; 0x88uy; 0xe0uy; 0x20uy; 0xcauy; 0xb7uy; 0x1buy; 0xf1uy; 0x2fuy; 0x5cuy; 0xeeuy; 0xd4uy; 0xd3uy; 0xa3uy; 0xccuy; 0xa4uy; 0x1euy; 0x1cuy; 0x47uy; 0xfbuy; 0xbfuy; 0xfcuy; 0xa2uy; 0x41uy; 0x55uy; 0x9duy; 0xf6uy; 0x5auy; 0x5euy; 0x65uy; 0x32uy; 0x34uy; 0x7buy; 0x52uy; 0x8duy; 0xd5uy; 0xd0uy; 0x20uy; 0x60uy; 0x03uy; 0xabuy; 0x3fuy; 0x8cuy; 0xd4uy; 0x21uy; 0xeauy; 0x2auy; 0xd9uy; 0xc4uy; 0xd0uy; 0xd3uy; 0x65uy; 0xd8uy; 0x7auy; 0x13uy; 0x28uy; 0x62uy; 0x32uy; 0x4buy; 0x2cuy; 0x87uy; 0x93uy; 0xa8uy; 0xb4uy; 0x52uy; 0x45uy; 0x09uy; 0x44uy; 0xecuy; 0xecuy; 0xc3uy; 0x17uy; 0xdbuy; 0x9auy; 0x4duy; 0x5cuy; 0xa9uy; 0x11uy; 0xd4uy; 0x7duy; 0xafuy; 0x9euy; 0xf1uy; 0x2duy; 0xb2uy; 0x66uy; 0xc5uy; 0x1duy; 0xeduy; 0xb7uy; 0xcduy; 0x0buy; 0x25uy; 0x5euy; 0x30uy; 0x47uy; 0x3fuy; 0x40uy; 0xf4uy; 0xa1uy; 0xa0uy; 0x00uy; 0x94uy; 0x10uy; 0xc5uy; 0x6auy; 0x63uy; 0x1auy; 0xd5uy; 0x88uy; 0x92uy; 0x8euy; 0x82uy; 0x39uy; 0x87uy; 0x3cuy; 0x78uy; 0x65uy; 0x58uy; 0x42uy; 0x75uy; 0x5buy; 0xdduy; 0x77uy; 0x3euy; 0x09uy; 0x4euy; 0x76uy; 0x5buy; 0xe6uy; 0x0euy; 0x4duy; 0x38uy; 0xb2uy; 0xc0uy; 0xb8uy; 0x95uy; 0x01uy; 0x7auy; 0x10uy; 0xe0uy; 0xfbuy; 0x07uy; 0xf2uy; 0xabuy; 0x2duy; 0x8cuy; 0x32uy; 0xeduy; 0x2buy; 0xc0uy; 0x46uy; 0xc2uy; 0xf5uy; 0x38uy; 0x83uy; 0xf0uy; 0x17uy; 0xecuy; 0xc1uy; 0x20uy; 0x6auy; 0x9auy; 0x0buy; 0x00uy; 0xa0uy; 0x98uy; 0x22uy; 0x50uy; 0x23uy; 0xd5uy; 0x80uy; 0x6buy; 0xf6uy; 0x1fuy; 0xc3uy; 0xccuy; 0x97uy; 0xc9uy; 0x24uy; 0x9fuy; 0xf3uy; 0xafuy; 0x43uy; 0x14uy; 0xd5uy; 0xa0uy; ] in assert_norm (List.Tot.length l = 1040); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let output9_len: (x:UInt32.t { UInt32.v x = B.length output9 }) = 1040ul let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) = [@inline_let] let l = [ 0x35uy; 0x4euy; 0xb5uy; 0x70uy; 0x50uy; 0x42uy; 0x8auy; 0x85uy; 0xf2uy; 0xfbuy; 0xeduy; 0x7buy; 0xd0uy; 0x9euy; 0x97uy; 0xcauy; 0xfauy; 0x98uy; 0x66uy; 0x63uy; 0xeeuy; 0x37uy; 0xccuy; 0x52uy; 0xfeuy; 0xd1uy; 0xdfuy; 0x95uy; 0x15uy; 0x34uy; 0x29uy; 0x38uy; ] 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 nonce10: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) = [@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfduy; 0x87uy; 0xd4uy; 0xd8uy; 0x62uy; 0xfduy; 0xecuy; 0xaauy; ] in assert_norm (List.Tot.length l = 12); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let nonce10_len: (x:UInt32.t { UInt32.v x = B.length nonce10 }) = 12ul let aad10: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) = [@inline_let] let l = [ 0xd6uy; 0x31uy; 0xdauy; 0x5duy; 0x42uy; 0x5euy; 0xd7uy; ] in assert_norm (List.Tot.length l = 7); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let aad10_len: (x:UInt32.t { UInt32.v x = B.length aad10 }) = 7ul let input10: (b: B.buffer UInt8.t { B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10 }) = B.recall aad10;[@inline_let] let l = [ 0x7auy; 0x57uy; 0xf2uy; 0xc7uy; 0x06uy; 0x3fuy; 0x50uy; 0x7buy; 0x36uy; 0x1auy; 0x66uy; 0x5cuy; 0xb9uy; 0x0euy; 0x5euy; 0x3buy; 0x45uy; 0x60uy; 0xbeuy; 0x9auy; 0x31uy; 0x9fuy; 0xffuy; 0x5duy; 0x66uy; 0x34uy; 0xb4uy; 0xdcuy; 0xfbuy; 0x9duy; 0x8euy; 0xeeuy; 0x6auy; 0x33uy; 0xa4uy; 0x07uy; 0x3cuy; 0xf9uy; 0x4cuy; 0x30uy; 0xa1uy; 0x24uy; 0x52uy; 0xf9uy; 0x50uy; 0x46uy; 0x88uy; 0x20uy; 0x02uy; 0x32uy; 0x3auy; 0x0euy; 0x99uy; 0x63uy; 0xafuy; 0x1fuy; 0x15uy; 0x28uy; 0x2auy; 0x05uy; 0xffuy; 0x57uy; 0x59uy; 0x5euy; 0x18uy; 0xa1uy; 0x1fuy; 0xd0uy; 0x92uy; 0x5cuy; 0x88uy; 0x66uy; 0x1buy; 0x00uy; 0x64uy; 0xa5uy; 0x93uy; 0x8duy; 0x06uy; 0x46uy; 0xb0uy; 0x64uy; 0x8buy; 0x8buy; 0xefuy; 0x99uy; 0x05uy; 0x35uy; 0x85uy; 0xb3uy; 0xf3uy; 0x33uy; 0xbbuy; 0xecuy; 0x66uy; 0xb6uy; 0x3duy; 0x57uy; 0x42uy; 0xe3uy; 0xb4uy; 0xc6uy; 0xaauy; 0xb0uy; 0x41uy; 0x2auy; 0xb9uy; 0x59uy; 0xa9uy; 0xf6uy; 0x3euy; 0x15uy; 0x26uy; 0x12uy; 0x03uy; 0x21uy; 0x4cuy; 0x74uy; 0x43uy; 0x13uy; 0x2auy; 0x03uy; 0x27uy; 0x09uy; 0xb4uy; 0xfbuy; 0xe7uy; 0xb7uy; 0x40uy; 0xffuy; 0x5euy; 0xceuy; 0x48uy; 0x9auy; 0x60uy; 0xe3uy; 0x8buy; 0x80uy; 0x8cuy; 0x38uy; 0x2duy; 0xcbuy; 0x93uy; 0x37uy; 0x74uy; 0x05uy; 0x52uy; 0x6fuy; 0x73uy; 0x3euy; 0xc3uy; 0xbcuy; 0xcauy; 0x72uy; 0x0auy; 0xebuy; 0xf1uy; 0x3buy; 0xa0uy; 0x95uy; 0xdcuy; 0x8auy; 0xc4uy; 0xa9uy; 0xdcuy; 0xcauy; 0x44uy; 0xd8uy; 0x08uy; 0x63uy; 0x6auy; 0x36uy; 0xd3uy; 0x3cuy; 0xb8uy; 0xacuy; 0x46uy; 0x7duy; 0xfduy; 0xaauy; 0xebuy; 0x3euy; 0x0fuy; 0x45uy; 0x8fuy; 0x49uy; 0xdauy; 0x2buy; 0xf2uy; 0x12uy; 0xbduy; 0xafuy; 0x67uy; 0x8auy; 0x63uy; 0x48uy; 0x4buy; 0x55uy; 0x5fuy; 0x6duy; 0x8cuy; 0xb9uy; 0x76uy; 0x34uy; 0x84uy; 0xaeuy; 0xc2uy; 0xfcuy; 0x52uy; 0x64uy; 0x82uy; 0xf7uy; 0xb0uy; 0x06uy; 0xf0uy; 0x45uy; 0x73uy; 0x12uy; 0x50uy; 0x30uy; 0x72uy; 0xeauy; 0x78uy; 0x9auy; 0xa8uy; 0xafuy; 0xb5uy; 0xe3uy; 0xbbuy; 0x77uy; 0x52uy; 0xecuy; 0x59uy; 0x84uy; 0xbfuy; 0x6buy; 0x8fuy; 0xceuy; 0x86uy; 0x5euy; 0x1fuy; 0x23uy; 0xe9uy; 0xfbuy; 0x08uy; 0x86uy; 0xf7uy; 0x10uy; 0xb9uy; 0xf2uy; 0x44uy; 0x96uy; 0x44uy; 0x63uy; 0xa9uy; 0xa8uy; 0x78uy; 0x00uy; 0x23uy; 0xd6uy; 0xc7uy; 0xe7uy; 0x6euy; 0x66uy; 0x4fuy; 0xccuy; 0xeeuy; 0x15uy; 0xb3uy; 0xbduy; 0x1duy; 0xa0uy; 0xe5uy; 0x9cuy; 0x1buy; 0x24uy; 0x2cuy; 0x4duy; 0x3cuy; 0x62uy; 0x35uy; 0x9cuy; 0x88uy; 0x59uy; 0x09uy; 0xdduy; 0x82uy; 0x1buy; 0xcfuy; 0x0auy; 0x83uy; 0x6buy; 0x3fuy; 0xaeuy; 0x03uy; 0xc4uy; 0xb4uy; 0xdduy; 0x7euy; 0x5buy; 0x28uy; 0x76uy; 0x25uy; 0x96uy; 0xd9uy; 0xc9uy; 0x9duy; 0x5fuy; 0x86uy; 0xfauy; 0xf6uy; 0xd7uy; 0xd2uy; 0xe6uy; 0x76uy; 0x1duy; 0x0fuy; 0xa1uy; 0xdcuy; 0x74uy; 0x05uy; 0x1buy; 0x1duy; 0xe0uy; 0xcduy; 0x16uy; 0xb0uy; 0xa8uy; 0x8auy; 0x34uy; 0x7buy; 0x15uy; 0x11uy; 0x77uy; 0xe5uy; 0x7buy; 0x7euy; 0x20uy; 0xf7uy; 0xdauy; 0x38uy; 0xdauy; 0xceuy; 0x70uy; 0xe9uy; 0xf5uy; 0x6cuy; 0xd9uy; 0xbeuy; 0x0cuy; 0x4cuy; 0x95uy; 0x4cuy; 0xc2uy; 0x9buy; 0x34uy; 0x55uy; 0x55uy; 0xe1uy; 0xf3uy; 0x46uy; 0x8euy; 0x48uy; 0x74uy; 0x14uy; 0x4fuy; 0x9duy; 0xc9uy; 0xf5uy; 0xe8uy; 0x1auy; 0xf0uy; 0x11uy; 0x4auy; 0xc1uy; 0x8duy; 0xe0uy; 0x93uy; 0xa0uy; 0xbeuy; 0x09uy; 0x1cuy; 0x2buy; 0x4euy; 0x0fuy; 0xb2uy; 0x87uy; 0x8buy; 0x84uy; 0xfeuy; 0x92uy; 0x32uy; 0x14uy; 0xd7uy; 0x93uy; 0xdfuy; 0xe7uy; 0x44uy; 0xbcuy; 0xc5uy; 0xaeuy; 0x53uy; 0x69uy; 0xd8uy; 0xb3uy; 0x79uy; 0x37uy; 0x80uy; 0xe3uy; 0x17uy; 0x5cuy; 0xecuy; 0x53uy; 0x00uy; 0x9auy; 0xe3uy; 0x8euy; 0xdcuy; 0x38uy; 0xb8uy; 0x66uy; 0xf0uy; 0xd3uy; 0xaduy; 0x1duy; 0x02uy; 0x96uy; 0x86uy; 0x3euy; 0x9duy; 0x3buy; 0x5duy; 0xa5uy; 0x7fuy; 0x21uy; 0x10uy; 0xf1uy; 0x1fuy; 0x13uy; 0x20uy; 0xf9uy; 0x57uy; 0x87uy; 0x20uy; 0xf5uy; 0x5fuy; 0xf1uy; 0x17uy; 0x48uy; 0x0auy; 0x51uy; 0x5auy; 0xcduy; 0x19uy; 0x03uy; 0xa6uy; 0x5auy; 0xd1uy; 0x12uy; 0x97uy; 0xe9uy; 0x48uy; 0xe2uy; 0x1duy; 0x83uy; 0x75uy; 0x50uy; 0xd9uy; 0x75uy; 0x7duy; 0x6auy; 0x82uy; 0xa1uy; 0xf9uy; 0x4euy; 0x54uy; 0x87uy; 0x89uy; 0xc9uy; 0x0cuy; 0xb7uy; 0x5buy; 0x6auy; 0x91uy; 0xc1uy; 0x9cuy; 0xb2uy; 0xa9uy; 0xdcuy; 0x9auy; 0xa4uy; 0x49uy; 0x0auy; 0x6duy; 0x0duy; 0xbbuy; 0xdeuy; 0x86uy; 0x44uy; 0xdduy; 0x5duy; 0x89uy; 0x2buy; 0x96uy; 0x0fuy; 0x23uy; 0x95uy; 0xaduy; 0xccuy; 0xa2uy; 0xb3uy; 0xb9uy; 0x7euy; 0x74uy; 0x38uy; 0xbauy; 0x9fuy; 0x73uy; 0xaeuy; 0x5fuy; 0xf8uy; 0x68uy; 0xa2uy; 0xe0uy; 0xa9uy; 0xceuy; 0xbduy; 0x40uy; 0xd4uy; 0x4cuy; 0x6buy; 0xd2uy; 0x56uy; 0x62uy; 0xb0uy; 0xccuy; 0x63uy; 0x7euy; 0x5buy; 0xd3uy; 0xaeuy; 0xd1uy; 0x75uy; 0xceuy; 0xbbuy; 0xb4uy; 0x5buy; 0xa8uy; 0xf8uy; 0xb4uy; 0xacuy; 0x71uy; 0x75uy; 0xaauy; 0xc9uy; 0x9fuy; 0xbbuy; 0x6cuy; 0xaduy; 0x0fuy; 0x55uy; 0x5duy; 0xe8uy; 0x85uy; 0x7duy; 0xf9uy; 0x21uy; 0x35uy; 0xeauy; 0x92uy; 0x85uy; 0x2buy; 0x00uy; 0xecuy; 0x84uy; 0x90uy; 0x0auy; 0x63uy; 0x96uy; 0xe4uy; 0x6buy; 0xa9uy; 0x77uy; 0xb8uy; 0x91uy; 0xf8uy; 0x46uy; 0x15uy; 0x72uy; 0x63uy; 0x70uy; 0x01uy; 0x40uy; 0xa3uy; 0xa5uy; 0x76uy; 0x62uy; 0x2buy; 0xbfuy; 0xf1uy; 0xe5uy; 0x8duy; 0x9fuy; 0xa3uy; 0xfauy; 0x9buy; 0x03uy; 0xbeuy; 0xfeuy; 0x65uy; 0x6fuy; 0xa2uy; 0x29uy; 0x0duy; 0x54uy; 0xb4uy; 0x71uy; 0xceuy; 0xa9uy; 0xd6uy; 0x3duy; 0x88uy; 0xf9uy; 0xafuy; 0x6buy; 0xa8uy; 0x9euy; 0xf4uy; 0x16uy; 0x96uy; 0x36uy; 0xb9uy; 0x00uy; 0xdcuy; 0x10uy; 0xabuy; 0xb5uy; 0x08uy; 0x31uy; 0x1fuy; 0x00uy; 0xb1uy; 0x3cuy; 0xd9uy; 0x38uy; 0x3euy; 0xc6uy; 0x04uy; 0xa7uy; 0x4euy; 0xe8uy; 0xaeuy; 0xeduy; 0x98uy; 0xc2uy; 0xf7uy; 0xb9uy; 0x00uy; 0x5fuy; 0x8cuy; 0x60uy; 0xd1uy; 0xe5uy; 0x15uy; 0xf7uy; 0xaeuy; 0x1euy; 0x84uy; 0x88uy; 0xd1uy; 0xf6uy; 0xbcuy; 0x3auy; 0x89uy; 0x35uy; 0x22uy; 0x83uy; 0x7cuy; 0xcauy; 0xf0uy; 0x33uy; 0x82uy; 0x4cuy; 0x79uy; 0x3cuy; 0xfduy; 0xb1uy; 0xaeuy; 0x52uy; 0x62uy; 0x55uy; 0xd2uy; 0x41uy; 0x60uy; 0xc6uy; 0xbbuy; 0xfauy; 0x0euy; 0x59uy; 0xd6uy; 0xa8uy; 0xfeuy; 0x5duy; 0xeduy; 0x47uy; 0x3duy; 0xe0uy; 0xeauy; 0x1fuy; 0x6euy; 0x43uy; 0x51uy; 0xecuy; 0x10uy; 0x52uy; 0x56uy; 0x77uy; 0x42uy; 0x6buy; 0x52uy; 0x87uy; 0xd8uy; 0xecuy; 0xe0uy; 0xaauy; 0x76uy; 0xa5uy; 0x84uy; 0x2auy; 0x22uy; 0x24uy; 0xfduy; 0x92uy; 0x40uy; 0x88uy; 0xd5uy; 0x85uy; 0x1cuy; 0x1fuy; 0x6buy; 0x47uy; 0xa0uy; 0xc4uy; 0xe4uy; 0xefuy; 0xf4uy; 0xeauy; 0xd7uy; 0x59uy; 0xacuy; 0x2auy; 0x9euy; 0x8cuy; 0xfauy; 0x1fuy; 0x42uy; 0x08uy; 0xfeuy; 0x4fuy; 0x74uy; 0xa0uy; 0x26uy; 0xf5uy; 0xb3uy; 0x84uy; 0xf6uy; 0x58uy; 0x5fuy; 0x26uy; 0x66uy; 0x3euy; 0xd7uy; 0xe4uy; 0x22uy; 0x91uy; 0x13uy; 0xc8uy; 0xacuy; 0x25uy; 0x96uy; 0x23uy; 0xd8uy; 0x09uy; 0xeauy; 0x45uy; 0x75uy; 0x23uy; 0xb8uy; 0x5fuy; 0xc2uy; 0x90uy; 0x8buy; 0x09uy; 0xc4uy; 0xfcuy; 0x47uy; 0x6cuy; 0x6duy; 0x0auy; 0xefuy; 0x69uy; 0xa4uy; 0x38uy; 0x19uy; 0xcfuy; 0x7duy; 0xf9uy; 0x09uy; 0x73uy; 0x9buy; 0x60uy; 0x5auy; 0xf7uy; 0x37uy; 0xb5uy; 0xfeuy; 0x9fuy; 0xe3uy; 0x2buy; 0x4cuy; 0x0duy; 0x6euy; 0x19uy; 0xf1uy; 0xd6uy; 0xc0uy; 0x70uy; 0xf3uy; 0x9duy; 0x22uy; 0x3cuy; 0xf9uy; 0x49uy; 0xceuy; 0x30uy; 0x8euy; 0x44uy; 0xb5uy; 0x76uy; 0x15uy; 0x8fuy; 0x52uy; 0xfduy; 0xa5uy; 0x04uy; 0xb8uy; 0x55uy; 0x6auy; 0x36uy; 0x59uy; 0x7cuy; 0xc4uy; 0x48uy; 0xb8uy; 0xd7uy; 0xabuy; 0x05uy; 0x66uy; 0xe9uy; 0x5euy; 0x21uy; 0x6fuy; 0x6buy; 0x36uy; 0x29uy; 0xbbuy; 0xe9uy; 0xe3uy; 0xa2uy; 0x9auy; 0xa8uy; 0xcduy; 0x55uy; 0x25uy; 0x11uy; 0xbauy; 0x5auy; 0x58uy; 0xa0uy; 0xdeuy; 0xaeuy; 0x19uy; 0x2auy; 0x48uy; 0x5auy; 0xffuy; 0x36uy; 0xcduy; 0x6duy; 0x16uy; 0x7auy; 0x73uy; 0x38uy; 0x46uy; 0xe5uy; 0x47uy; 0x59uy; 0xc8uy; 0xa2uy; 0xf6uy; 0xe2uy; 0x6cuy; 0x83uy; 0xc5uy; 0x36uy; 0x2cuy; 0x83uy; 0x7duy; 0xb4uy; 0x01uy; 0x05uy; 0x69uy; 0xe7uy; 0xafuy; 0x5cuy; 0xc4uy; 0x64uy; 0x82uy; 0x12uy; 0x21uy; 0xefuy; 0xf7uy; 0xd1uy; 0x7duy; 0xb8uy; 0x8duy; 0x8cuy; 0x98uy; 0x7cuy; 0x5fuy; 0x7duy; 0x92uy; 0x88uy; 0xb9uy; 0x94uy; 0x07uy; 0x9cuy; 0xd8uy; 0xe9uy; 0x9cuy; 0x17uy; 0x38uy; 0xe3uy; 0x57uy; 0x6cuy; 0xe0uy; 0xdcuy; 0xa5uy; 0x92uy; 0x42uy; 0xb3uy; 0xbduy; 0x50uy; 0xa2uy; 0x7euy; 0xb5uy; 0xb1uy; 0x52uy; 0x72uy; 0x03uy; 0x97uy; 0xd8uy; 0xaauy; 0x9auy; 0x1euy; 0x75uy; 0x41uy; 0x11uy; 0xa3uy; 0x4fuy; 0xccuy; 0xd4uy; 0xe3uy; 0x73uy; 0xaduy; 0x96uy; 0xdcuy; 0x47uy; 0x41uy; 0x9fuy; 0xb0uy; 0xbeuy; 0x79uy; 0x91uy; 0xf5uy; 0xb6uy; 0x18uy; 0xfeuy; 0xc2uy; 0x83uy; 0x18uy; 0x7duy; 0x73uy; 0xd9uy; 0x4fuy; 0x83uy; 0x84uy; 0x03uy; 0xb3uy; 0xf0uy; 0x77uy; 0x66uy; 0x3duy; 0x83uy; 0x63uy; 0x2euy; 0x2cuy; 0xf9uy; 0xdduy; 0xa6uy; 0x1fuy; 0x89uy; 0x82uy; 0xb8uy; 0x23uy; 0x42uy; 0xebuy; 0xe2uy; 0xcauy; 0x70uy; 0x82uy; 0x61uy; 0x41uy; 0x0auy; 0x6duy; 0x5fuy; 0x75uy; 0xc5uy; 0xe2uy; 0xc4uy; 0x91uy; 0x18uy; 0x44uy; 0x22uy; 0xfauy; 0x34uy; 0x10uy; 0xf5uy; 0x20uy; 0xdcuy; 0xb7uy; 0xdduy; 0x2auy; 0x20uy; 0x77uy; 0xf5uy; 0xf9uy; 0xceuy; 0xdbuy; 0xa0uy; 0x0auy; 0x52uy; 0x2auy; 0x4euy; 0xdduy; 0xccuy; 0x97uy; 0xdfuy; 0x05uy; 0xe4uy; 0x5euy; 0xb7uy; 0xaauy; 0xf0uy; 0xe2uy; 0x80uy; 0xffuy; 0xbauy; 0x1auy; 0x0fuy; 0xacuy; 0xdfuy; 0x02uy; 0x32uy; 0xe6uy; 0xf7uy; 0xc7uy; 0x17uy; 0x13uy; 0xb7uy; 0xfcuy; 0x98uy; 0x48uy; 0x8cuy; 0x0duy; 0x82uy; 0xc9uy; 0x80uy; 0x7auy; 0xe2uy; 0x0auy; 0xc5uy; 0xb4uy; 0xdeuy; 0x7cuy; 0x3cuy; 0x79uy; 0x81uy; 0x0euy; 0x28uy; 0x65uy; 0x79uy; 0x67uy; 0x82uy; 0x69uy; 0x44uy; 0x66uy; 0x09uy; 0xf7uy; 0x16uy; 0x1auy; 0xf9uy; 0x7duy; 0x80uy; 0xa1uy; 0x79uy; 0x14uy; 0xa9uy; 0xc8uy; 0x20uy; 0xfbuy; 0xa2uy; 0x46uy; 0xbeuy; 0x08uy; 0x35uy; 0x17uy; 0x58uy; 0xc1uy; 0x1auy; 0xdauy; 0x2auy; 0x6buy; 0x2euy; 0x1euy; 0xe6uy; 0x27uy; 0x55uy; 0x7buy; 0x19uy; 0xe2uy; 0xfbuy; 0x64uy; 0xfcuy; 0x5euy; 0x15uy; 0x54uy; 0x3cuy; 0xe7uy; 0xc2uy; 0x11uy; 0x50uy; 0x30uy; 0xb8uy; 0x72uy; 0x03uy; 0x0buy; 0x1auy; 0x9fuy; 0x86uy; 0x27uy; 0x11uy; 0x5cuy; 0x06uy; 0x2buy; 0xbduy; 0x75uy; 0x1auy; 0x0auy; 0xdauy; 0x01uy; 0xfauy; 0x5cuy; 0x4auy; 0xc1uy; 0x80uy; 0x3auy; 0x6euy; 0x30uy; 0xc8uy; 0x2cuy; 0xebuy; 0x56uy; 0xecuy; 0x89uy; 0xfauy; 0x35uy; 0x7buy; 0xb2uy; 0xf0uy; 0x97uy; 0x08uy; 0x86uy; 0x53uy; 0xbeuy; 0xbduy; 0x40uy; 0x41uy; 0x38uy; 0x1cuy; 0xb4uy; 0x8buy; 0x79uy; 0x2euy; 0x18uy; 0x96uy; 0x94uy; 0xdeuy; 0xe8uy; 0xcauy; 0xe5uy; 0x9fuy; 0x92uy; 0x9fuy; 0x15uy; 0x5duy; 0x56uy; 0x60uy; 0x5cuy; 0x09uy; 0xf9uy; 0x16uy; 0xf4uy; 0x17uy; 0x0fuy; 0xf6uy; 0x4cuy; 0xdauy; 0xe6uy; 0x67uy; 0x89uy; 0x9fuy; 0xcauy; 0x6cuy; 0xe7uy; 0x9buy; 0x04uy; 0x62uy; 0x0euy; 0x26uy; 0xa6uy; 0x52uy; 0xbduy; 0x29uy; 0xffuy; 0xc7uy; 0xa4uy; 0x96uy; 0xe6uy; 0x6auy; 0x02uy; 0xa5uy; 0x2euy; 0x7buy; 0xfeuy; 0x97uy; 0x68uy; 0x3euy; 0x2euy; 0x5fuy; 0x3buy; 0x0fuy; 0x36uy; 0xd6uy; 0x98uy; 0x19uy; 0x59uy; 0x48uy; 0xd2uy; 0xc6uy; 0xe1uy; 0x55uy; 0x1auy; 0x6euy; 0xd6uy; 0xeduy; 0x2cuy; 0xbauy; 0xc3uy; 0x9euy; 0x64uy; 0xc9uy; 0x95uy; 0x86uy; 0x35uy; 0x5euy; 0x3euy; 0x88uy; 0x69uy; 0x99uy; 0x4buy; 0xeeuy; 0xbeuy; 0x9auy; 0x99uy; 0xb5uy; 0x6euy; 0x58uy; 0xaeuy; 0xdduy; 0x22uy; 0xdbuy; 0xdduy; 0x6buy; 0xfcuy; 0xafuy; 0x90uy; 0xa3uy; 0x3duy; 0xa4uy; 0xc1uy; 0x15uy; 0x92uy; 0x18uy; 0x8duy; 0xd2uy; 0x4buy; 0x7buy; 0x06uy; 0xd1uy; 0x37uy; 0xb5uy; 0xe2uy; 0x7cuy; 0x2cuy; 0xf0uy; 0x25uy; 0xe4uy; 0x94uy; 0x2auy; 0xbduy; 0xe3uy; 0x82uy; 0x70uy; 0x78uy; 0xa3uy; 0x82uy; 0x10uy; 0x5auy; 0x90uy; 0xd7uy; 0xa4uy; 0xfauy; 0xafuy; 0x1auy; 0x88uy; 0x59uy; 0xdcuy; 0x74uy; 0x12uy; 0xb4uy; 0x8euy; 0xd7uy; 0x19uy; 0x46uy; 0xf4uy; 0x84uy; 0x69uy; 0x9fuy; 0xbbuy; 0x70uy; 0xa8uy; 0x4cuy; 0x52uy; 0x81uy; 0xa9uy; 0xffuy; 0x76uy; 0x1cuy; 0xaeuy; 0xd8uy; 0x11uy; 0x3duy; 0x7fuy; 0x7duy; 0xc5uy; 0x12uy; 0x59uy; 0x28uy; 0x18uy; 0xc2uy; 0xa2uy; 0xb7uy; 0x1cuy; 0x88uy; 0xf8uy; 0xd6uy; 0x1buy; 0xa6uy; 0x7duy; 0x9euy; 0xdeuy; 0x29uy; 0xf8uy; 0xeduy; 0xffuy; 0xebuy; 0x92uy; 0x24uy; 0x4fuy; 0x05uy; 0xaauy; 0xd9uy; 0x49uy; 0xbauy; 0x87uy; 0x59uy; 0x51uy; 0xc9uy; 0x20uy; 0x5cuy; 0x9buy; 0x74uy; 0xcfuy; 0x03uy; 0xd9uy; 0x2duy; 0x34uy; 0xc7uy; 0x5buy; 0xa5uy; 0x40uy; 0xb2uy; 0x99uy; 0xf5uy; 0xcbuy; 0xb4uy; 0xf6uy; 0xb7uy; 0x72uy; 0x4auy; 0xd6uy; 0xbduy; 0xb0uy; 0xf3uy; 0x93uy; 0xe0uy; 0x1buy; 0xa8uy; 0x04uy; 0x1euy; 0x35uy; 0xd4uy; 0x80uy; 0x20uy; 0xf4uy; 0x9cuy; 0x31uy; 0x6buy; 0x45uy; 0xb9uy; 0x15uy; 0xb0uy; 0x5euy; 0xdduy; 0x0auy; 0x33uy; 0x9cuy; 0x83uy; 0xcduy; 0x58uy; 0x89uy; 0x50uy; 0x56uy; 0xbbuy; 0x81uy; 0x00uy; 0x91uy; 0x32uy; 0xf3uy; 0x1buy; 0x3euy; 0xcfuy; 0x45uy; 0xe1uy; 0xf9uy; 0xe1uy; 0x2cuy; 0x26uy; 0x78uy; 0x93uy; 0x9auy; 0x60uy; 0x46uy; 0xc9uy; 0xb5uy; 0x5euy; 0x6auy; 0x28uy; 0x92uy; 0x87uy; 0x3fuy; 0x63uy; 0x7buy; 0xdbuy; 0xf7uy; 0xd0uy; 0x13uy; 0x9duy; 0x32uy; 0x40uy; 0x5euy; 0xcfuy; 0xfbuy; 0x79uy; 0x68uy; 0x47uy; 0x4cuy; 0xfduy; 0x01uy; 0x17uy; 0xe6uy; 0x97uy; 0x93uy; 0x78uy; 0xbbuy; 0xa6uy; 0x27uy; 0xa3uy; 0xe8uy; 0x1auy; 0xe8uy; 0x94uy; 0x55uy; 0x7duy; 0x08uy; 0xe5uy; 0xdcuy; 0x66uy; 0xa3uy; 0x69uy; 0xc8uy; 0xcauy; 0xc5uy; 0xa1uy; 0x84uy; 0x55uy; 0xdeuy; 0x08uy; 0x91uy; 0x16uy; 0x3auy; 0x0cuy; 0x86uy; 0xabuy; 0x27uy; 0x2buy; 0x64uy; 0x34uy; 0x02uy; 0x6cuy; 0x76uy; 0x8buy; 0xc6uy; 0xafuy; 0xccuy; 0xe1uy; 0xd6uy; 0x8cuy; 0x2auy; 0x18uy; 0x3duy; 0xa6uy; 0x1buy; 0x37uy; 0x75uy; 0x45uy; 0x73uy; 0xc2uy; 0x75uy; 0xd7uy; 0x53uy; 0x78uy; 0x3auy; 0xd6uy; 0xe8uy; 0x29uy; 0xd2uy; 0x4auy; 0xa8uy; 0x1euy; 0x82uy; 0xf6uy; 0xb6uy; 0x81uy; 0xdeuy; 0x21uy; 0xeduy; 0x2buy; 0x56uy; 0xbbuy; 0xf2uy; 0xd0uy; 0x57uy; 0xc1uy; 0x7cuy; 0xd2uy; 0x6auy; 0xd2uy; 0x56uy; 0xf5uy; 0x13uy; 0x5fuy; 0x1cuy; 0x6auy; 0x0buy; 0x74uy; 0xfbuy; 0xe9uy; 0xfeuy; 0x9euy; 0xeauy; 0x95uy; 0xb2uy; 0x46uy; 0xabuy; 0x0auy; 0xfcuy; 0xfduy; 0xf3uy; 0xbbuy; 0x04uy; 0x2buy; 0x76uy; 0x1buy; 0xa4uy; 0x74uy; 0xb0uy; 0xc1uy; 0x78uy; 0xc3uy; 0x69uy; 0xe2uy; 0xb0uy; 0x01uy; 0xe1uy; 0xdeuy; 0x32uy; 0x4cuy; 0x8duy; 0x1auy; 0xb3uy; 0x38uy; 0x08uy; 0xd5uy; 0xfcuy; 0x1fuy; 0xdcuy; 0x0euy; 0x2cuy; 0x9cuy; 0xb1uy; 0xa1uy; 0x63uy; 0x17uy; 0x22uy; 0xf5uy; 0x6cuy; 0x93uy; 0x70uy; 0x74uy; 0x00uy; 0xf8uy; 0x39uy; 0x01uy; 0x94uy; 0xd1uy; 0x32uy; 0x23uy; 0x56uy; 0x5duy; 0xa6uy; 0x02uy; 0x76uy; 0x76uy; 0x93uy; 0xceuy; 0x2fuy; 0x19uy; 0xe9uy; 0x17uy; 0x52uy; 0xaeuy; 0x6euy; 0x2cuy; 0x6duy; 0x61uy; 0x7fuy; 0x3buy; 0xaauy; 0xe0uy; 0x52uy; 0x85uy; 0xc5uy; 0x65uy; 0xc1uy; 0xbbuy; 0x8euy; 0x5buy; 0x21uy; 0xd5uy; 0xc9uy; 0x78uy; 0x83uy; 0x07uy; 0x97uy; 0x4cuy; 0x62uy; 0x61uy; 0x41uy; 0xd4uy; 0xfcuy; 0xc9uy; 0x39uy; 0xe3uy; 0x9buy; 0xd0uy; 0xccuy; 0x75uy; 0xc4uy; 0x97uy; 0xe6uy; 0xdduy; 0x2auy; 0x5fuy; 0xa6uy; 0xe8uy; 0x59uy; 0x6cuy; 0x98uy; 0xb9uy; 0x02uy; 0xe2uy; 0xa2uy; 0xd6uy; 0x68uy; 0xeeuy; 0x3buy; 0x1duy; 0xe3uy; 0x4duy; 0x5buy; 0x30uy; 0xefuy; 0x03uy; 0xf2uy; 0xebuy; 0x18uy; 0x57uy; 0x36uy; 0xe8uy; 0xa1uy; 0xf4uy; 0x47uy; 0xfbuy; 0xcbuy; 0x8fuy; 0xcbuy; 0xc8uy; 0xf3uy; 0x4fuy; 0x74uy; 0x9duy; 0x9duy; 0xb1uy; 0x8duy; 0x14uy; 0x44uy; 0xd9uy; 0x19uy; 0xb4uy; 0x54uy; 0x4fuy; 0x75uy; 0x19uy; 0x09uy; 0xa0uy; 0x75uy; 0xbcuy; 0x3buy; 0x82uy; 0xc6uy; 0x3fuy; 0xb8uy; 0x83uy; 0x19uy; 0x6euy; 0xd6uy; 0x37uy; 0xfeuy; 0x6euy; 0x8auy; 0x4euy; 0xe0uy; 0x4auy; 0xabuy; 0x7buy; 0xc8uy; 0xb4uy; 0x1duy; 0xf4uy; 0xeduy; 0x27uy; 0x03uy; 0x65uy; 0xa2uy; 0xa1uy; 0xaeuy; 0x11uy; 0xe7uy; 0x98uy; 0x78uy; 0x48uy; 0x91uy; 0xd2uy; 0xd2uy; 0xd4uy; 0x23uy; 0x78uy; 0x50uy; 0xb1uy; 0x5buy; 0x85uy; 0x10uy; 0x8duy; 0xcauy; 0x5fuy; 0x0fuy; 0x71uy; 0xaeuy; 0x72uy; 0x9auy; 0xf6uy; 0x25uy; 0x19uy; 0x60uy; 0x06uy; 0xf7uy; 0x10uy; 0x34uy; 0x18uy; 0x0duy; 0xc9uy; 0x9fuy; 0x7buy; 0x0cuy; 0x9buy; 0x8fuy; 0x91uy; 0x1buy; 0x9fuy; 0xcduy; 0x10uy; 0xeeuy; 0x75uy; 0xf9uy; 0x97uy; 0x66uy; 0xfcuy; 0x4duy; 0x33uy; 0x6euy; 0x28uy; 0x2buy; 0x92uy; 0x85uy; 0x4fuy; 0xabuy; 0x43uy; 0x8duy; 0x8fuy; 0x7duy; 0x86uy; 0xa7uy; 0xc7uy; 0xd8uy; 0xd3uy; 0x0buy; 0x8buy; 0x57uy; 0xb6uy; 0x1duy; 0x95uy; 0x0duy; 0xe9uy; 0xbcuy; 0xd9uy; 0x03uy; 0xd9uy; 0x10uy; 0x19uy; 0xc3uy; 0x46uy; 0x63uy; 0x55uy; 0x87uy; 0x61uy; 0x79uy; 0x6cuy; 0x95uy; 0x0euy; 0x9cuy; 0xdduy; 0xcauy; 0xc3uy; 0xf3uy; 0x64uy; 0xf0uy; 0x7duy; 0x76uy; 0xb7uy; 0x53uy; 0x67uy; 0x2buy; 0x1euy; 0x44uy; 0x56uy; 0x81uy; 0xeauy; 0x8fuy; 0x5cuy; 0x42uy; 0x16uy; 0xb8uy; 0x28uy; 0xebuy; 0x1buy; 0x61uy; 0x10uy; 0x1euy; 0xbfuy; 0xecuy; 0xa8uy; ] in assert_norm (List.Tot.length l = 1933); B.gcmalloc_of_list HyperStack.root l inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) = 1933ul	{ "checked_file": "/", "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.Chacha20Poly1305.fst" }	[ { "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 } ]	{ "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" }	false	b: LowStar.Buffer.buffer FStar.UInt8.t {LowStar.Monotonic.Buffer.length b = 1949 /\ LowStar.Monotonic.Buffer.recallable b}	Prims.Tot	[ "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" ]	[]	false	false	false	false	false	let output10:(b: B.buffer UInt8.t {B.length b = 1949 /\ B.recallable b}) =	[@@ inline_let ]let l = [ 0x6auy; 0xfcuy; 0x4buy; 0x25uy; 0xdfuy; 0xc0uy; 0xe4uy; 0xe8uy; 0x17uy; 0x4duy; 0x4cuy; 0xc9uy; 0x7euy; 0xdeuy; 0x3auy; 0xccuy; 0x3cuy; 0xbauy; 0x6auy; 0x77uy; 0x47uy; 0xdbuy; 0xe3uy; 0x74uy; 0x7auy; 0x4duy; 0x5fuy; 0x8duy; 0x37uy; 0x55uy; 0x80uy; 0x73uy; 0x90uy; 0x66uy; 0x5duy; 0x3auy; 0x7duy; 0x5duy; 0x86uy; 0x5euy; 0x8duy; 0xfduy; 0x83uy; 0xffuy; 0x4euy; 0x74uy; 0x6fuy; 0xf9uy; 0xe6uy; 0x70uy; 0x17uy; 0x70uy; 0x3euy; 0x96uy; 0xa7uy; 0x7euy; 0xcbuy; 0xabuy; 0x8fuy; 0x58uy; 0x24uy; 0x9buy; 0x01uy; 0xfduy; 0xcbuy; 0xe6uy; 0x4duy; 0x9buy; 0xf0uy; 0x88uy; 0x94uy; 0x57uy; 0x66uy; 0xefuy; 0x72uy; 0x4cuy; 0x42uy; 0x6euy; 0x16uy; 0x19uy; 0x15uy; 0xeauy; 0x70uy; 0x5buy; 0xacuy; 0x13uy; 0xdbuy; 0x9fuy; 0x18uy; 0xe2uy; 0x3cuy; 0x26uy; 0x97uy; 0xbcuy; 0xdcuy; 0x45uy; 0x8cuy; 0x6cuy; 0x24uy; 0x69uy; 0x9cuy; 0xf7uy; 0x65uy; 0x1euy; 0x18uy; 0x59uy; 0x31uy; 0x7cuy; 0xe4uy; 0x73uy; 0xbcuy; 0x39uy; 0x62uy; 0xc6uy; 0x5cuy; 0x9fuy; 0xbfuy; 0xfauy; 0x90uy; 0x03uy; 0xc9uy; 0x72uy; 0x26uy; 0xb6uy; 0x1buy; 0xc2uy; 0xb7uy; 0x3fuy; 0xf2uy; 0x13uy; 0x77uy; 0xf2uy; 0x8duy; 0xb9uy; 0x47uy; 0xd0uy; 0x53uy; 0xdduy; 0xc8uy; 0x91uy; 0x83uy; 0x8buy; 0xb1uy; 0xceuy; 0xa3uy; 0xfeuy; 0xcduy; 0xd9uy; 0xdduy; 0x92uy; 0x7buy; 0xdbuy; 0xb8uy; 0xfbuy; 0xc9uy; 0x2duy; 0x01uy; 0x59uy; 0x39uy; 0x52uy; 0xaduy; 0x1buy; 0xecuy; 0xcfuy; 0xd7uy; 0x70uy; 0x13uy; 0x21uy; 0xf5uy; 0x47uy; 0xaauy; 0x18uy; 0x21uy; 0x5cuy; 0xc9uy; 0x9auy; 0xd2uy; 0x6buy; 0x05uy; 0x9cuy; 0x01uy; 0xa1uy; 0xdauy; 0x35uy; 0x5duy; 0xb3uy; 0x70uy; 0xe6uy; 0xa9uy; 0x80uy; 0x8buy; 0x91uy; 0xb7uy; 0xb3uy; 0x5fuy; 0x24uy; 0x9auy; 0xb7uy; 0xd1uy; 0x6buy; 0xa1uy; 0x1cuy; 0x50uy; 0xbauy; 0x49uy; 0xe0uy; 0xeeuy; 0x2euy; 0x75uy; 0xacuy; 0x69uy; 0xc0uy; 0xebuy; 0x03uy; 0xdduy; 0x19uy; 0xe5uy; 0xf6uy; 0x06uy; 0xdduy; 0xc3uy; 0xd7uy; 0x2buy; 0x07uy; 0x07uy; 0x30uy; 0xa7uy; 0x19uy; 0x0cuy; 0xbfuy; 0xe6uy; 0x18uy; 0xccuy; 0xb1uy; 0x01uy; 0x11uy; 0x85uy; 0x77uy; 0x1duy; 0x96uy; 0xa7uy; 0xa3uy; 0x00uy; 0x84uy; 0x02uy; 0xa2uy; 0x83uy; 0x68uy; 0xdauy; 0x17uy; 0x27uy; 0xc8uy; 0x7fuy; 0x23uy; 0xb7uy; 0xf4uy; 0x13uy; 0x85uy; 0xcfuy; 0xdduy; 0x7auy; 0x7duy; 0x24uy; 0x57uy; 0xfeuy; 0x05uy; 0x93uy; 0xf5uy; 0x74uy; 0xceuy; 0xeduy; 0x0cuy; 0x20uy; 0x98uy; 0x8duy; 0x92uy; 0x30uy; 0xa1uy; 0x29uy; 0x23uy; 0x1auy; 0xa0uy; 0x4fuy; 0x69uy; 0x56uy; 0x4cuy; 0xe1uy; 0xc8uy; 0xceuy; 0xf6uy; 0x9auy; 0x0cuy; 0xa4uy; 0xfauy; 0x04uy; 0xf6uy; 0x62uy; 0x95uy; 0xf2uy; 0xfauy; 0xc7uy; 0x40uy; 0x68uy; 0x40uy; 0x8fuy; 0x41uy; 0xdauy; 0xb4uy; 0x26uy; 0x6fuy; 0x70uy; 0xabuy; 0x40uy; 0x61uy; 0xa4uy; 0x0euy; 0x75uy; 0xfbuy; 0x86uy; 0xebuy; 0x9duy; 0x9auy; 0x1fuy; 0xecuy; 0x76uy; 0x99uy; 0xe7uy; 0xeauy; 0xaauy; 0x1euy; 0x2duy; 0xb5uy; 0xd4uy; 0xa6uy; 0x1auy; 0xb8uy; 0x61uy; 0x0auy; 0x1duy; 0x16uy; 0x5buy; 0x98uy; 0xc2uy; 0x31uy; 0x40uy; 0xe7uy; 0x23uy; 0x1duy; 0x66uy; 0x99uy; 0xc8uy; 0xc0uy; 0xd7uy; 0xceuy; 0xf3uy; 0x57uy; 0x40uy; 0x04uy; 0x3fuy; 0xfcuy; 0xeauy; 0xb3uy; 0xfcuy; 0xd2uy; 0xd3uy; 0x99uy; 0xa4uy; 0x94uy; 0x69uy; 0xa0uy; 0xefuy; 0xd1uy; 0x85uy; 0xb3uy; 0xa6uy; 0xb1uy; 0x28uy; 0xbfuy; 0x94uy; 0x67uy; 0x22uy; 0xc3uy; 0x36uy; 0x46uy; 0xf8uy; 0xd2uy; 0x0fuy; 0x5fuy; 0xf4uy; 0x59uy; 0x80uy; 0xe6uy; 0x2duy; 0x43uy; 0x08uy; 0x7duy; 0x19uy; 0x09uy; 0x97uy; 0xa7uy; 0x4cuy; 0x3duy; 0x8duy; 0xbauy; 0x65uy; 0x62uy; 0xa3uy; 0x71uy; 0x33uy; 0x29uy; 0x62uy; 0xdbuy; 0xc1uy; 0x33uy; 0x34uy; 0x1auy; 0x63uy; 0x33uy; 0x16uy; 0xb6uy; 0x64uy; 0x7euy; 0xabuy; 0x33uy; 0xf0uy; 0xe6uy; 0x26uy; 0x68uy; 0xbauy; 0x1duy; 0x2euy; 0x38uy; 0x08uy; 0xe6uy; 0x02uy; 0xd3uy; 0x25uy; 0x2cuy; 0x47uy; 0x23uy; 0x58uy; 0x34uy; 0x0fuy; 0x9duy; 0x63uy; 0x4fuy; 0x63uy; 0xbbuy; 0x7fuy; 0x3buy; 0x34uy; 0x38uy; 0xa7uy; 0xb5uy; 0x8duy; 0x65uy; 0xd9uy; 0x9fuy; 0x79uy; 0x55uy; 0x3euy; 0x4duy; 0xe7uy; 0x73uy; 0xd8uy; 0xf6uy; 0x98uy; 0x97uy; 0x84uy; 0x60uy; 0x9cuy; 0xc8uy; 0xa9uy; 0x3cuy; 0xf6uy; 0xdcuy; 0x12uy; 0x5cuy; 0xe1uy; 0xbbuy; 0x0buy; 0x8buy; 0x98uy; 0x9cuy; 0x9duy; 0x26uy; 0x7cuy; 0x4auy; 0xe6uy; 0x46uy; 0x36uy; 0x58uy; 0x21uy; 0x4auy; 0xeeuy; 0xcauy; 0xd7uy; 0x3buy; 0xc2uy; 0x6cuy; 0x49uy; 0x2fuy; 0xe5uy; 0xd5uy; 0x03uy; 0x59uy; 0x84uy; 0x53uy; 0xcbuy; 0xfeuy; 0x92uy; 0x71uy; 0x2euy; 0x7cuy; 0x21uy; 0xccuy; 0x99uy; 0x85uy; 0x7fuy; 0xb8uy; 0x74uy; 0x90uy; 0x13uy; 0x42uy; 0x3fuy; 0xe0uy; 0x6buy; 0x1duy; 0xf2uy; 0x4duy; 0x54uy; 0xd4uy; 0xfcuy; 0x3auy; 0x05uy; 0xe6uy; 0x74uy; 0xafuy; 0xa6uy; 0xa0uy; 0x2auy; 0x20uy; 0x23uy; 0x5duy; 0x34uy; 0x5cuy; 0xd9uy; 0x3euy; 0x4euy; 0xfauy; 0x93uy; 0xe7uy; 0xaauy; 0xe9uy; 0x6fuy; 0x08uy; 0x43uy; 0x67uy; 0x41uy; 0xc5uy; 0xaduy; 0xfbuy; 0x31uy; 0x95uy; 0x82uy; 0x73uy; 0x32uy; 0xd8uy; 0xa6uy; 0xa3uy; 0xeduy; 0x0euy; 0x2duy; 0xf6uy; 0x5fuy; 0xfduy; 0x80uy; 0xa6uy; 0x7auy; 0xe0uy; 0xdfuy; 0x78uy; 0x15uy; 0x29uy; 0x74uy; 0x33uy; 0xd0uy; 0x9euy; 0x83uy; 0x86uy; 0x72uy; 0x22uy; 0x57uy; 0x29uy; 0xb9uy; 0x9euy; 0x5duy; 0xd3uy; 0x1auy; 0xb5uy; 0x96uy; 0x72uy; 0x41uy; 0x3duy; 0xf1uy; 0x64uy; 0x43uy; 0x67uy; 0xeeuy; 0xaauy; 0x5cuy; 0xd3uy; 0x9auy; 0x96uy; 0x13uy; 0x11uy; 0x5duy; 0xf3uy; 0x0cuy; 0x87uy; 0x82uy; 0x1euy; 0x41uy; 0x9euy; 0xd0uy; 0x27uy; 0xd7uy; 0x54uy; 0x3buy; 0x67uy; 0x73uy; 0x09uy; 0x91uy; 0xe9uy; 0xd5uy; 0x36uy; 0xa7uy; 0xb5uy; 0x55uy; 0xe4uy; 0xf3uy; 0x21uy; 0x51uy; 0x49uy; 0x22uy; 0x07uy; 0x55uy; 0x4fuy; 0x44uy; 0x4buy; 0xd2uy; 0x15uy; 0x93uy; 0x17uy; 0x2auy; 0xfauy; 0x4duy; 0x4auy; 0x57uy; 0xdbuy; 0x4cuy; 0xa6uy; 0xebuy; 0xecuy; 0x53uy; 0x25uy; 0x6cuy; 0x21uy; 0xeduy; 0x00uy; 0x4cuy; 0x3buy; 0xcauy; 0x14uy; 0x57uy; 0xa9uy; 0xd6uy; 0x6auy; 0xcduy; 0x8duy; 0x5euy; 0x74uy; 0xacuy; 0x72uy; 0xc1uy; 0x97uy; 0xe5uy; 0x1buy; 0x45uy; 0x4euy; 0xdauy; 0xfcuy; 0xccuy; 0x40uy; 0xe8uy; 0x48uy; 0x88uy; 0x0buy; 0xa3uy; 0xe3uy; 0x8duy; 0x83uy; 0x42uy; 0xc3uy; 0x23uy; 0xfduy; 0x68uy; 0xb5uy; 0x8euy; 0xf1uy; 0x9duy; 0x63uy; 0x77uy; 0xe9uy; 0xa3uy; 0x8euy; 0x8cuy; 0x26uy; 0x6buy; 0xbduy; 0x72uy; 0x73uy; 0x35uy; 0x0cuy; 0x03uy; 0xf8uy; 0x43uy; 0x78uy; 0x52uy; 0x71uy; 0x15uy; 0x1fuy; 0x71uy; 0x5duy; 0x6euy; 0xeduy; 0xb9uy; 0xccuy; 0x86uy; 0x30uy; 0xdbuy; 0x2buy; 0xd3uy; 0x82uy; 0x88uy; 0x23uy; 0x71uy; 0x90uy; 0x53uy; 0x5cuy; 0xa9uy; 0x2fuy; 0x76uy; 0x01uy; 0xb7uy; 0x9auy; 0xfeuy; 0x43uy; 0x55uy; 0xa3uy; 0x04uy; 0x9buy; 0x0euy; 0xe4uy; 0x59uy; 0xdfuy; 0xc9uy; 0xe9uy; 0xb1uy; 0xeauy; 0x29uy; 0x28uy; 0x3cuy; 0x5cuy; 0xaeuy; 0x72uy; 0x84uy; 0xb6uy; 0xc6uy; 0xebuy; 0x0cuy; 0x27uy; 0x07uy; 0x74uy; 0x90uy; 0x0duy; 0x31uy; 0xb0uy; 0x00uy; 0x77uy; 0xe9uy; 0x40uy; 0x70uy; 0x6fuy; 0x68uy; 0xa7uy; 0xfduy; 0x06uy; 0xecuy; 0x4buy; 0xc0uy; 0xb7uy; 0xacuy; 0xbcuy; 0x33uy; 0xb7uy; 0x6duy; 0x0auy; 0xbduy; 0x12uy; 0x1buy; 0x59uy; 0xcbuy; 0xdduy; 0x32uy; 0xf5uy; 0x1duy; 0x94uy; 0x57uy; 0x76uy; 0x9euy; 0x0cuy; 0x18uy; 0x98uy; 0x71uy; 0xd7uy; 0x2auy; 0xdbuy; 0x0buy; 0x7buy; 0xa7uy; 0x71uy; 0xb7uy; 0x67uy; 0x81uy; 0x23uy; 0x96uy; 0xaeuy; 0xb9uy; 0x7euy; 0x32uy; 0x43uy; 0x92uy; 0x8auy; 0x19uy; 0xa0uy; 0xc4uy; 0xd4uy; 0x3buy; 0x57uy; 0xf9uy; 0x4auy; 0x2cuy; 0xfbuy; 0x51uy; 0x46uy; 0xbbuy; 0xcbuy; 0x5duy; 0xb3uy; 0xefuy; 0x13uy; 0x93uy; 0x6euy; 0x68uy; 0x42uy; 0x54uy; 0x57uy; 0xd3uy; 0x6auy; 0x3auy; 0x8fuy; 0x9duy; 0x66uy; 0xbfuy; 0xbduy; 0x36uy; 0x23uy; 0xf5uy; 0x93uy; 0x83uy; 0x7buy; 0x9cuy; 0xc0uy; 0xdduy; 0xc5uy; 0x49uy; 0xc0uy; 0x64uy; 0xeduy; 0x07uy; 0x12uy; 0xb3uy; 0xe6uy; 0xe4uy; 0xe5uy; 0x38uy; 0x95uy; 0x23uy; 0xb1uy; 0xa0uy; 0x3buy; 0x1auy; 0x61uy; 0xdauy; 0x17uy; 0xacuy; 0xc3uy; 0x58uy; 0xdduy; 0x74uy; 0x64uy; 0x22uy; 0x11uy; 0xe8uy; 0x32uy; 0x1duy; 0x16uy; 0x93uy; 0x85uy; 0x99uy; 0xa5uy; 0x9cuy; 0x34uy; 0x55uy; 0xb1uy; 0xe9uy; 0x20uy; 0x72uy; 0xc9uy; 0x28uy; 0x7buy; 0x79uy; 0x00uy; 0xa1uy; 0xa6uy; 0xa3uy; 0x27uy; 0x40uy; 0x18uy; 0x8auy; 0x54uy; 0xe0uy; 0xccuy; 0xe8uy; 0x4euy; 0x8euy; 0x43uy; 0x96uy; 0xe7uy; 0x3fuy; 0xc8uy; 0xe9uy; 0xb2uy; 0xf9uy; 0xc9uy; 0xdauy; 0x04uy; 0x71uy; 0x50uy; 0x47uy; 0xe4uy; 0xaauy; 0xceuy; 0xa2uy; 0x30uy; 0xc8uy; 0xe4uy; 0xacuy; 0xc7uy; 0x0duy; 0x06uy; 0x2euy; 0xe6uy; 0xe8uy; 0x80uy; 0x36uy; 0x29uy; 0x9euy; 0x01uy; 0xb8uy; 0xc3uy; 0xf0uy; 0xa0uy; 0x5duy; 0x7auy; 0xcauy; 0x4duy; 0xa0uy; 0x57uy; 0xbduy; 0x2auy; 0x45uy; 0xa7uy; 0x7fuy; 0x9cuy; 0x93uy; 0x07uy; 0x8fuy; 0x35uy; 0x67uy; 0x92uy; 0xe3uy; 0xe9uy; 0x7fuy; 0xa8uy; 0x61uy; 0x43uy; 0x9euy; 0x25uy; 0x4fuy; 0x33uy; 0x76uy; 0x13uy; 0x6euy; 0x12uy; 0xb9uy; 0xdduy; 0xa4uy; 0x7cuy; 0x08uy; 0x9fuy; 0x7cuy; 0xe7uy; 0x0auy; 0x8duy; 0x84uy; 0x06uy; 0xa4uy; 0x33uy; 0x17uy; 0x34uy; 0x5euy; 0x10uy; 0x7cuy; 0xc0uy; 0xa8uy; 0x3duy; 0x1fuy; 0x42uy; 0x20uy; 0x51uy; 0x65uy; 0x5duy; 0x09uy; 0xc3uy; 0xaauy; 0xc0uy; 0xc8uy; 0x0duy; 0xf0uy; 0x79uy; 0xbcuy; 0x20uy; 0x1buy; 0x95uy; 0xe7uy; 0x06uy; 0x7duy; 0x47uy; 0x20uy; 0x03uy; 0x1auy; 0x74uy; 0xdduy; 0xe2uy; 0xd4uy; 0xaeuy; 0x38uy; 0x71uy; 0x9buy; 0xf5uy; 0x80uy; 0xecuy; 0x08uy; 0x4euy; 0x56uy; 0xbauy; 0x76uy; 0x12uy; 0x1auy; 0xdfuy; 0x48uy; 0xf3uy; 0xaeuy; 0xb3uy; 0xe6uy; 0xe6uy; 0xbeuy; 0xc0uy; 0x91uy; 0x2euy; 0x01uy; 0xb3uy; 0x01uy; 0x86uy; 0xa2uy; 0xb9uy; 0x52uy; 0xd1uy; 0x21uy; 0xaeuy; 0xd4uy; 0x97uy; 0x1duy; 0xefuy; 0x41uy; 0x12uy; 0x95uy; 0x3duy; 0x48uy; 0x45uy; 0x1cuy; 0x56uy; 0x32uy; 0x8fuy; 0xb8uy; 0x43uy; 0xbbuy; 0x19uy; 0xf3uy; 0xcauy; 0xe9uy; 0xebuy; 0x6duy; 0x84uy; 0xbeuy; 0x86uy; 0x06uy; 0xe2uy; 0x36uy; 0xb2uy; 0x62uy; 0x9duy; 0xd3uy; 0x4cuy; 0x48uy; 0x18uy; 0x54uy; 0x13uy; 0x4euy; 0xcfuy; 0xfduy; 0xbauy; 0x84uy; 0xb9uy; 0x30uy; 0x53uy; 0xcfuy; 0xfbuy; 0xb9uy; 0x29uy; 0x8fuy; 0xdcuy; 0x9fuy; 0xefuy; 0x60uy; 0x0buy; 0x64uy; 0xf6uy; 0x8buy; 0xeeuy; 0xa6uy; 0x91uy; 0xc2uy; 0x41uy; 0x6cuy; 0xf6uy; 0xfauy; 0x79uy; 0x67uy; 0x4buy; 0xc1uy; 0x3fuy; 0xafuy; 0x09uy; 0x81uy; 0xd4uy; 0x5duy; 0xcbuy; 0x09uy; 0xdfuy; 0x36uy; 0x31uy; 0xc0uy; 0x14uy; 0x3cuy; 0x7cuy; 0x0euy; 0x65uy; 0x95uy; 0x99uy; 0x6duy; 0xa3uy; 0xf4uy; 0xd7uy; 0x38uy; 0xeeuy; 0x1auy; 0x2buy; 0x37uy; 0xe2uy; 0xa4uy; 0x3buy; 0x4buy; 0xd0uy; 0x65uy; 0xcauy; 0xf8uy; 0xc3uy; 0xe8uy; 0x15uy; 0x20uy; 0xefuy; 0xf2uy; 0x00uy; 0xfduy; 0x01uy; 0x09uy; 0xc5uy; 0xc8uy; 0x17uy; 0x04uy; 0x93uy; 0xd0uy; 0x93uy; 0x03uy; 0x55uy; 0xc5uy; 0xfeuy; 0x32uy; 0xa3uy; 0x3euy; 0x28uy; 0x2duy; 0x3buy; 0x93uy; 0x8auy; 0xccuy; 0x07uy; 0x72uy; 0x80uy; 0x8buy; 0x74uy; 0x16uy; 0x24uy; 0xbbuy; 0xdauy; 0x94uy; 0x39uy; 0x30uy; 0x8fuy; 0xb1uy; 0xcduy; 0x4auy; 0x90uy; 0x92uy; 0x7cuy; 0x14uy; 0x8fuy; 0x95uy; 0x4euy; 0xacuy; 0x9buy; 0xd8uy; 0x8fuy; 0x1auy; 0x87uy; 0xa4uy; 0x32uy; 0x27uy; 0x8auy; 0xbauy; 0xf7uy; 0x41uy; 0xcfuy; 0x84uy; 0x37uy; 0x19uy; 0xe6uy; 0x06uy; 0xf5uy; 0x0euy; 0xcfuy; 0x36uy; 0xf5uy; 0x9euy; 0x6cuy; 0xdeuy; 0xbcuy; 0xffuy; 0x64uy; 0x7euy; 0x4euy; 0x59uy; 0x57uy; 0x48uy; 0xfeuy; 0x14uy; 0xf7uy; 0x9cuy; 0x93uy; 0x5duy; 0x15uy; 0xaduy; 0xccuy; 0x11uy; 0xb1uy; 0x17uy; 0x18uy; 0xb2uy; 0x7euy; 0xccuy; 0xabuy; 0xe9uy; 0xceuy; 0x7duy; 0x77uy; 0x5buy; 0x51uy; 0x1buy; 0x1euy; 0x20uy; 0xa8uy; 0x32uy; 0x06uy; 0x0euy; 0x75uy; 0x93uy; 0xacuy; 0xdbuy; 0x35uy; 0x37uy; 0x1fuy; 0xe9uy; 0x19uy; 0x1duy; 0xb4uy; 0x71uy; 0x97uy; 0xd6uy; 0x4euy; 0x2cuy; 0x08uy; 0xa5uy; 0x13uy; 0xf9uy; 0x0euy; 0x7euy; 0x78uy; 0x6euy; 0x14uy; 0xe0uy; 0xa9uy; 0xb9uy; 0x96uy; 0x4cuy; 0x80uy; 0x82uy; 0xbauy; 0x17uy; 0xb3uy; 0x9duy; 0x69uy; 0xb0uy; 0x84uy; 0x46uy; 0xffuy; 0xf9uy; 0x52uy; 0x79uy; 0x94uy; 0x58uy; 0x3auy; 0x62uy; 0x90uy; 0x15uy; 0x35uy; 0x71uy; 0x10uy; 0x37uy; 0xeduy; 0xa1uy; 0x8euy; 0x53uy; 0x6euy; 0xf4uy; 0x26uy; 0x57uy; 0x93uy; 0x15uy; 0x93uy; 0xf6uy; 0x81uy; 0x2cuy; 0x5auy; 0x10uy; 0xdauy; 0x92uy; 0xaduy; 0x2fuy; 0xdbuy; 0x28uy; 0x31uy; 0x2duy; 0x55uy; 0x04uy; 0xd2uy; 0x06uy; 0x28uy; 0x8cuy; 0x1euy; 0xdcuy; 0xeauy; 0x54uy; 0xacuy; 0xffuy; 0xb7uy; 0x6cuy; 0x30uy; 0x15uy; 0xd4uy; 0xb4uy; 0x0duy; 0x00uy; 0x93uy; 0x57uy; 0xdduy; 0xd2uy; 0x07uy; 0x07uy; 0x06uy; 0xd9uy; 0x43uy; 0x9buy; 0xcduy; 0x3auy; 0xf4uy; 0x7duy; 0x4cuy; 0x36uy; 0x5duy; 0x23uy; 0xa2uy; 0xccuy; 0x57uy; 0x40uy; 0x91uy; 0xe9uy; 0x2cuy; 0x2fuy; 0x2cuy; 0xd5uy; 0x30uy; 0x9buy; 0x17uy; 0xb0uy; 0xc9uy; 0xf7uy; 0xa7uy; 0x2fuy; 0xd1uy; 0x93uy; 0x20uy; 0x6buy; 0xc6uy; 0xc1uy; 0xe4uy; 0x6fuy; 0xcbuy; 0xd1uy; 0xe7uy; 0x09uy; 0x0fuy; 0x9euy; 0xdcuy; 0xaauy; 0x9fuy; 0x2fuy; 0xdfuy; 0x56uy; 0x9fuy; 0xd4uy; 0x33uy; 0x04uy; 0xafuy; 0xd3uy; 0x6cuy; 0x58uy; 0x61uy; 0xf0uy; 0x30uy; 0xecuy; 0xf2uy; 0x7fuy; 0xf2uy; 0x9cuy; 0xdfuy; 0x39uy; 0xbbuy; 0x6fuy; 0xa2uy; 0x8cuy; 0x7euy; 0xc4uy; 0x22uy; 0x51uy; 0x71uy; 0xc0uy; 0x4duy; 0x14uy; 0x1auy; 0xc4uy; 0xcduy; 0x04uy; 0xd9uy; 0x87uy; 0x08uy; 0x50uy; 0x05uy; 0xccuy; 0xafuy; 0xf6uy; 0xf0uy; 0x8fuy; 0x92uy; 0x54uy; 0x58uy; 0xc2uy; 0xc7uy; 0x09uy; 0x7auy; 0x59uy; 0x02uy; 0x05uy; 0xe8uy; 0xb0uy; 0x86uy; 0xd9uy; 0xbfuy; 0x7buy; 0x35uy; 0x51uy; 0x4duy; 0xafuy; 0x08uy; 0x97uy; 0x2cuy; 0x65uy; 0xdauy; 0x2auy; 0x71uy; 0x3auy; 0xa8uy; 0x51uy; 0xccuy; 0xf2uy; 0x73uy; 0x27uy; 0xc3uy; 0xfduy; 0x62uy; 0xcfuy; 0xe3uy; 0xb2uy; 0xcauy; 0xcbuy; 0xbeuy; 0x1auy; 0x0auy; 0xa1uy; 0x34uy; 0x7buy; 0x77uy; 0xc4uy; 0x62uy; 0x68uy; 0x78uy; 0x5fuy; 0x94uy; 0x07uy; 0x04uy; 0x65uy; 0x16uy; 0x4buy; 0x61uy; 0xcbuy; 0xffuy; 0x75uy; 0x26uy; 0x50uy; 0x66uy; 0x1fuy; 0x6euy; 0x93uy; 0xf8uy; 0xc5uy; 0x51uy; 0xebuy; 0xa4uy; 0x4auy; 0x48uy; 0x68uy; 0x6buy; 0xe2uy; 0x5euy; 0x44uy; 0xb2uy; 0x50uy; 0x2cuy; 0x6cuy; 0xaeuy; 0x79uy; 0x4euy; 0x66uy; 0x35uy; 0x81uy; 0x50uy; 0xacuy; 0xbcuy; 0x3fuy; 0xb1uy; 0x0cuy; 0xf3uy; 0x05uy; 0x3cuy; 0x4auy; 0xa3uy; 0x6cuy; 0x2auy; 0x79uy; 0xb4uy; 0xb7uy; 0xabuy; 0xcauy; 0xc7uy; 0x9buy; 0x8euy; 0xcduy; 0x5fuy; 0x11uy; 0x03uy; 0xcbuy; 0x30uy; 0xa3uy; 0xabuy; 0xdauy; 0xfeuy; 0x64uy; 0xb9uy; 0xbbuy; 0xd8uy; 0x5euy; 0x3auy; 0x1auy; 0x56uy; 0xe5uy; 0x05uy; 0x48uy; 0x90uy; 0x1euy; 0x61uy; 0x69uy; 0x1buy; 0x22uy; 0xe6uy; 0x1auy; 0x3cuy; 0x75uy; 0xaduy; 0x1fuy; 0x37uy; 0x28uy; 0xdcuy; 0xe4uy; 0x6duy; 0xbduy; 0x42uy; 0xdcuy; 0xd3uy; 0xc8uy; 0xb6uy; 0x1cuy; 0x48uy; 0xfeuy; 0x94uy; 0x77uy; 0x7fuy; 0xbduy; 0x62uy; 0xacuy; 0xa3uy; 0x47uy; 0x27uy; 0xcfuy; 0x5fuy; 0xd9uy; 0xdbuy; 0xafuy; 0xecuy; 0xf7uy; 0x5euy; 0xc1uy; 0xb0uy; 0x9duy; 0x01uy; 0x26uy; 0x99uy; 0x7euy; 0x8fuy; 0x03uy; 0x70uy; 0xb5uy; 0x42uy; 0xbeuy; 0x67uy; 0x28uy; 0x1buy; 0x7cuy; 0xbduy; 0x61uy; 0x21uy; 0x97uy; 0xccuy; 0x5cuy; 0xe1uy; 0x97uy; 0x8fuy; 0x8duy; 0xdeuy; 0x2buy; 0xaauy; 0xa7uy; 0x71uy; 0x1duy; 0x1euy; 0x02uy; 0x73uy; 0x70uy; 0x58uy; 0x32uy; 0x5buy; 0x1duy; 0x67uy; 0x3duy; 0xe0uy; 0x74uy; 0x4fuy; 0x03uy; 0xf2uy; 0x70uy; 0x51uy; 0x79uy; 0xf1uy; 0x61uy; 0x70uy; 0x15uy; 0x74uy; 0x9duy; 0x23uy; 0x89uy; 0xdeuy; 0xacuy; 0xfduy; 0xdeuy; 0xd0uy; 0x1fuy; 0xc3uy; 0x87uy; 0x44uy; 0x35uy; 0x4buy; 0xe5uy; 0xb0uy; 0x60uy; 0xc5uy; 0x22uy; 0xe4uy; 0x9euy; 0xcauy; 0xebuy; 0xd5uy; 0x3auy; 0x09uy; 0x45uy; 0xa4uy; 0xdbuy; 0xfauy; 0x3fuy; 0xebuy; 0x1buy; 0xc7uy; 0xc8uy; 0x14uy; 0x99uy; 0x51uy; 0x92uy; 0x10uy; 0xeduy; 0xeduy; 0x28uy; 0xe0uy; 0xa1uy; 0xf8uy; 0x26uy; 0xcfuy; 0xcduy; 0xcbuy; 0x63uy; 0xa1uy; 0x3buy; 0xe3uy; 0xdfuy; 0x7euy; 0xfeuy; 0xa6uy; 0xf0uy; 0x81uy; 0x9auy; 0xbfuy; 0x55uy; 0xdeuy; 0x54uy; 0xd5uy; 0x56uy; 0x60uy; 0x98uy; 0x10uy; 0x68uy; 0xf4uy; 0x38uy; 0x96uy; 0x8euy; 0x6fuy; 0x1duy; 0x44uy; 0x7fuy; 0xd6uy; 0x2fuy; 0xfeuy; 0x55uy; 0xfbuy; 0x0cuy; 0x7euy; 0x67uy; 0xe2uy; 0x61uy; 0x44uy; 0xeduy; 0xf2uy; 0x35uy; 0x30uy; 0x5duy; 0xe9uy; 0xc7uy; 0xd6uy; 0x6duy; 0xe0uy; 0xa0uy; 0xeduy; 0xf3uy; 0xfcuy; 0xd8uy; 0x3euy; 0x0auy; 0x7buy; 0xcduy; 0xafuy; 0x65uy; 0x68uy; 0x18uy; 0xc0uy; 0xecuy; 0x04uy; 0x1cuy; 0x74uy; 0x6duy; 0xe2uy; 0x6euy; 0x79uy; 0xd4uy; 0x11uy; 0x2buy; 0x62uy; 0xd5uy; 0x27uy; 0xaduy; 0x4fuy; 0x01uy; 0x59uy; 0x73uy; 0xccuy; 0x6auy; 0x53uy; 0xfbuy; 0x2duy; 0xd5uy; 0x4euy; 0x99uy; 0x21uy; 0x65uy; 0x4duy; 0xf5uy; 0x82uy; 0xf7uy; 0xd8uy; 0x42uy; 0xceuy; 0x6fuy; 0x3duy; 0x36uy; 0x47uy; 0xf1uy; 0x05uy; 0x16uy; 0xe8uy; 0x1buy; 0x6auy; 0x8fuy; 0x93uy; 0xf2uy; 0x8fuy; 0x37uy; 0x40uy; 0x12uy; 0x28uy; 0xa3uy; 0xe6uy; 0xb9uy; 0x17uy; 0x4auy; 0x1fuy; 0xb1uy; 0xd1uy; 0x66uy; 0x69uy; 0x86uy; 0xc4uy; 0xfcuy; 0x97uy; 0xaeuy; 0x3fuy; 0x8fuy; 0x1euy; 0x2buy; 0xdfuy; 0xcduy; 0xf9uy; 0x3cuy ] in assert_norm (List.Tot.length l = 1949); B.gcmalloc_of_list HyperStack.root l	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_bounded_vldata_strong'	val validate_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s))	val validate_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s))	let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 48, "end_line": 186, "start_col": 0, "start_line": 168 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> s: LowParse.Spec.Base.serializer p -> v: LowParse.Low.Base.validator p -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.validator", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt64.t", "LowParse.Low.VLData.validate_bounded_vldata'", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata'", "LowParse.Low.ErrorCode.uint64_to_uint32", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong'", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get" ]	[]	false	false	false	false	false	let validate_bounded_vldata_strong' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) =	fun #rrel #rel input pos -> let h = HST.get () in [@@ inline_let ]let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@@ inline_let ]let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_vldata_gen_intro	val valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	val valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 67, "end_line": 265, "start_col": 0, "start_line": 237 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4"	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 4, "max_fuel": 8, "max_ifuel": 4, "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": 32, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	h: FStar.Monotonic.HyperStack.mem -> sz: LowParse.Spec.BoundedInt.integer_size -> f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.Pervasives.Lemma (requires FStar.UInt32.v pos + sz <= FStar.UInt32.v (Mkslice?.len input) /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_exact p h input pos_payload pos' /\ (let len_payload = FStar.UInt32.sub pos' pos_payload in LowParse.Spec.BoundedInt.bounded_integer_prop sz len_payload /\ f len_payload == true /\ LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos == len_payload))) (ensures LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLData.parse_vldata_gen sz f p) h input pos (LowParse.Low.Base.Spec.contents_exact p h input (FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz)) pos') pos')	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.bool", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.Base.Spec.contents_exact_eq", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "Prims.unit", "LowParse.Spec.VLData.parse_vldata_gen_eq", "LowParse.Slice.bytes_of_slice_from", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.parse_bounded_integer", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Spec.BoundedInt.bounded_integer_prop", "Prims.eq2", "LowParse.Low.Base.Spec.valid", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.sub", "Prims.squash", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Low.Base.Spec.contents_exact", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos')) =	valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` (U32.uint_to_t sz)) pos'	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.validate_bounded_vldata'	val validate_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p))	val validate_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p))	let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) ()	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 114, "start_col": 0, "start_line": 94 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> v: LowParse.Low.Base.validator p -> LowParse.Low.Base.validator (LowParse.Spec.VLData.parse_bounded_vldata' min max l p)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Low.Base.validator", "LowParse.Low.Combinators.validate_strengthen", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.BoundedInt.in_bounds", "LowParse.Low.VLData.validate_vldata_gen", "LowParse.Spec.BoundedInt.bounded_integer", "Prims.op_Equality", "Prims.int", "FStar.UInt32.lte", "FStar.UInt32.uint_to_t", "Prims.bool", "Prims.op_AmpAmp", "Prims.eq2", "Prims.unit", "LowParse.Spec.VLData.parse_bounded_vldata_correct", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.VLData.parse_bounded_vldata'" ]	[]	false	false	false	false	false	let validate_bounded_vldata' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) =	[@@ inline_let ]let sz:integer_size = l in [@@ inline_let ]let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` (U32.uint_to_t max) else ((U32.uint_to_t min) `U32.lte` i && i `U32.lte` (U32.uint_to_t max))) v) ()	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata'_elim	val valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata' min max l p) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos))))	val valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata' min max l p) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos))))	let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 60, "end_line": 329, "start_col": 0, "start_line": 300 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) h input pos) (ensures (let sz = l in LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ (let len_payload = LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ sz + FStar.UInt32.v len_payload == LowParse.Low.Base.Spec.content_length (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) h input pos /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) h input pos (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.valid_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.contents_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) == LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) h input pos))))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_vldata_gen_elim", "LowParse.Spec.BoundedInt.in_bounds", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata'", "LowParse.Low.Base.Spec.valid", "Prims.squash", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "FStar.UInt32.v", "Prims.eq2", "Prims.int", "Prims.op_Addition", "LowParse.Low.Base.Spec.content_length", "LowParse.Low.Base.Spec.valid_pos", "FStar.UInt32.add", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.contents_exact", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.uint_to_t", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata' min max l p) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos)))) =	valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata_elim	val valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata min max p) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos))))	val valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata min max p) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos))))	let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 64, "end_line": 356, "start_col": 0, "start_line": 331 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_bounded_vldata min max p) h input pos) (ensures (let sz = LowParse.Spec.BoundedInt.log256' max in LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ (let len_payload = LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ sz + FStar.UInt32.v len_payload == LowParse.Low.Base.Spec.content_length (LowParse.Spec.VLData.parse_bounded_vldata min max p) h input pos /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.VLData.parse_bounded_vldata min max p) h input pos (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.valid_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.contents_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) == LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_bounded_vldata min max p) h input pos))))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_bounded_vldata'_elim", "LowParse.Spec.BoundedInt.log256'", "Prims.unit", "LowParse.Low.Base.Spec.valid", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "Prims.squash", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "FStar.UInt32.v", "Prims.eq2", "Prims.int", "Prims.op_Addition", "LowParse.Low.Base.Spec.content_length", "LowParse.Low.Base.Spec.valid_pos", "FStar.UInt32.add", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.contents_exact", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata min max p) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos)))) =	valid_bounded_vldata'_elim h min max (log256' max) p input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata_intro	val valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	val valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos'))	let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 77, "end_line": 386, "start_col": 0, "start_line": 358 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.Pervasives.Lemma (requires (let sz = LowParse.Spec.BoundedInt.log256' max in FStar.UInt32.v pos + sz <= FStar.UInt32.v (Mkslice?.len input) /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_exact p h input pos_payload pos' /\ (let len_payload = FStar.UInt32.sub pos' pos_payload in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = LowParse.Spec.BoundedInt.log256' max in LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLData.parse_bounded_vldata min max p) h input pos (LowParse.Low.Base.Spec.contents_exact p h input (FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz)) pos') pos'))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_vldata_gen_intro", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.BoundedInt.in_bounds", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_vldata_gen_kind", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.valid", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "Prims.eq2", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.sub", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "Prims.squash", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Low.Base.Spec.contents_exact", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos') pos')) =	valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos'	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata_strong'_elim	val valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong' min max l s) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos))))	val valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong' min max l s) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos))))	let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 52, "end_line": 417, "start_col": 0, "start_line": 388 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s) h input pos) (ensures (let sz = l in LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ (let len_payload = LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ sz + FStar.UInt32.v len_payload == LowParse.Low.Base.Spec.content_length (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s) h input pos /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s) h input pos (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.valid_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.contents_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) == LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s) h input pos))))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "Prims.op_GreaterThanOrEqual", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_bounded_vldata'_elim", "Prims.unit", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong'", "LowParse.Low.Base.Spec.valid", "Prims.squash", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "FStar.UInt32.v", "Prims.eq2", "Prims.int", "Prims.op_Addition", "LowParse.Low.Base.Spec.content_length", "LowParse.Low.Base.Spec.valid_pos", "FStar.UInt32.add", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.contents_exact", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.uint_to_t", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (l: nat{l >= log256' max /\ l <= 4}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong' min max l s) h input pos)) (ensures (let sz = l in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos)))) =	valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata_strong_elim	val valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong min max s) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos))))	val valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong min max s) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos))))	let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 71, "end_line": 445, "start_col": 0, "start_line": 419 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) h input pos) (ensures (let sz = LowParse.Spec.BoundedInt.log256' max in LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ (let len_payload = LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ sz + FStar.UInt32.v len_payload == LowParse.Low.Base.Spec.content_length (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) h input pos /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) h input pos (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.valid_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) /\ LowParse.Low.Base.Spec.contents_exact p h input pos_payload (FStar.UInt32.add pos_payload len_payload) == LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) h input pos))))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_bounded_vldata_strong'_elim", "LowParse.Spec.BoundedInt.log256'", "Prims.unit", "LowParse.Low.Base.Spec.valid", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "Prims.squash", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "FStar.UInt32.v", "Prims.eq2", "Prims.int", "Prims.op_Addition", "LowParse.Low.Base.Spec.content_length", "LowParse.Low.Base.Spec.valid_pos", "FStar.UInt32.add", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.contents_exact", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_bounded_vldata_strong min max s) h input pos)) (ensures (let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ (let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos)))) =	valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.finalize_bounded_vldata	val finalize_bounded_vldata (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos'))	val finalize_bounded_vldata (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos'))	let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 56, "end_line": 633, "start_col": 0, "start_line": 605 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.finalize_bounded_vldata_exact", "Prims.unit", "FStar.Monotonic.HyperStack.mem", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_pos", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Pervasives.Native.uu___is_Some", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high", "FStar.Pervasives.Native.__proj__Some__item__v", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Low.Base.Spec.contents" ]	[]	false	true	false	false	false	let finalize_bounded_vldata (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos')) =	finalize_bounded_vldata_exact min max p input pos pos'	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.valid_bounded_vldata_strong_intro	val valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos'))	val valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos'))	let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 82, "end_line": 480, "start_col": 0, "start_line": 447 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	h: FStar.Monotonic.HyperStack.mem -> min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.Pervasives.Lemma (requires (let sz = LowParse.Spec.BoundedInt.log256' max in FStar.UInt32.v pos + sz <= FStar.UInt32.v (Mkslice?.len input) /\ (let pos_payload = FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz) in LowParse.Low.Base.Spec.valid_exact p h input pos_payload pos' /\ (let len_payload = FStar.UInt32.sub pos' pos_payload in min <= FStar.UInt32.v len_payload /\ FStar.UInt32.v len_payload <= max /\ LowParse.Low.Base.Spec.valid (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos /\ LowParse.Low.Base.Spec.contents (LowParse.Spec.BoundedInt.parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = LowParse.Spec.BoundedInt.log256' max in let x = LowParse.Low.Base.Spec.contents_exact p h input (FStar.UInt32.add pos (FStar.UInt32.uint_to_t sz)) pos' in FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v pos' - (FStar.UInt32.v pos + sz) /\ LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s x /\ LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) h input pos x pos'))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "FStar.Monotonic.HyperStack.mem", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.Base.Spec.valid_exact_serialize", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.log256'", "Prims.unit", "LowParse.Low.VLData.valid_bounded_vldata_intro", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.Spec.valid", "LowParse.Spec.BoundedInt.parse_bounded_integer_kind", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "Prims.eq2", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.sub", "LowParse.Spec.BoundedInt.integer_size", "Prims.squash", "Prims.int", "FStar.Seq.Base.length", "LowParse.Spec.Base.serialize", "Prims.op_Subtraction", "LowParse.Spec.VLData.parse_bounded_vldata_strong_pred", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Low.Base.Spec.contents_exact", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload)))) (ensures (let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos')) =	valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` (U32.uint_to_t (log256' max))) pos'	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.weak_finalize_bounded_vldata_strong	val weak_finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True)))	val weak_finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True)))	let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 68, "end_line": 717, "start_col": 0, "start_line": 677 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.bool	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.weak_finalize_bounded_vldata_strong_exact", "Prims.bool", "Prims.unit", "LowParse.Low.Base.Spec.valid_pos_valid_exact", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "LowParse.Low.Base.Spec.valid_pos", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "Prims.l_iff", "LowParse.Spec.VLData.parse_bounded_vldata_strong_pred", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.Base.Spec.contents", "Prims.l_True", "Prims.logical", "FStar.UInt32.sub" ]	[]	false	true	false	false	false	let weak_finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True))) =	let h = HST.get () in [@@ inline_let ]let _ = let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos'	false
LowParse.Low.Array.fst	LowParse.Low.Array.clens_array_nth	val clens_array_nth (t: Type) (elem_count: nat) (i: nat{i < elem_count}) : Tot (clens (array t elem_count) t)	val clens_array_nth (t: Type) (elem_count: nat) (i: nat{i < elem_count}) : Tot (clens (array t elem_count) t)	let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); }	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 1, "end_line": 57, "start_col": 0, "start_line": 49 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	t: Type -> elem_count: Prims.nat -> i: Prims.nat{i < elem_count} -> LowParse.Low.Base.Spec.clens (LowParse.Spec.Array.array t elem_count) t	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.b2t", "Prims.op_LessThan", "LowParse.Low.Base.Spec.Mkclens", "LowParse.Spec.Array.array", "Prims.l_True", "FStar.List.Tot.Base.index", "LowParse.Low.Base.Spec.clens" ]	[]	false	false	false	false	false	let clens_array_nth (t: Type) (elem_count: nat) (i: nat{i < elem_count}) : Tot (clens (array t elem_count) t) =	{ clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i) }	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.finalize_bounded_vldata_strong_exact	val finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos'))	val finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos'))	let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 62, "end_line": 525, "start_col": 0, "start_line": 483 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_bounded_vldata_strong_intro", "Prims.unit", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.BoundedInt.write_bounded_integer", "LowParse.Low.Base.Spec.valid_exact_serialize", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Low.Base.Spec.serialized_length_eq", "LowParse.Low.Base.Spec.contents_exact", "FStar.UInt32.sub", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "Prims.l_or", "FStar.Seq.Base.length", "LowParse.Spec.Base.serialize", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "Prims.eq2", "Prims.int", "Prims.op_Subtraction", "LowParse.Spec.VLData.parse_bounded_vldata_strong_pred", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong" ]	[]	false	true	false	false	false	let finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos')) =	[@@ inline_let ]let sz = log256' max in [@@ inline_let ]let len_payload = pos' `U32.sub` (pos `U32.add` (U32.uint_to_t sz)) in let h = HST.get () in [@@ inline_let ]let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos'); valid_exact_serialize s h input (pos `U32.add` (U32.uint_to_t sz)) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos'	false
LowParse.Low.Array.fst	LowParse.Low.Array.array_nth_ghost''	val array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat)	val array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat)	let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0)	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 10, "end_line": 79, "start_col": 0, "start_line": 62 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> elem_count: Prims.nat -> i: Prims.nat { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count } -> input: LowParse.Bytes.bytes -> Prims.GTot Prims.nat	Prims.GTot	[ "sometrivial" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.b2t", "Prims.op_LessThan", "LowParse.Bytes.bytes", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "Prims.op_Multiply", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Seq.Base.length", "LowParse.Bytes.byte" ]	[]	false	false	false	false	false	let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) =	if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0)	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.gaccessor_bounded_vldata_payload'	val gaccessor_bounded_vldata_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t))	val gaccessor_bounded_vldata_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t))	let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 742, "start_col": 0, "start_line": 720 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.VLData.parse_bounded_vldata min max p) p (LowParse.Low.Base.Spec.clens_id t)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Bytes.bytes", "FStar.Seq.Base.length", "LowParse.Bytes.byte", "Prims.bool", "Prims.unit", "LowParse.Spec.Base.parse", "LowParse.Spec.VLData.parse_bounded_vldata", "FStar.Pervasives.Native.tuple2", "LowParse.Spec.Base.consumed_length", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.Base.parse_strong_prefix", "FStar.Seq.Base.slice", "Prims.op_Addition", "FStar.UInt32.v", "Prims._assert", "Prims.l_or", "LowParse.Spec.BoundedInt.parse_bounded_integer", "LowParse.Spec.VLData.parse_vldata_gen_eq", "LowParse.Spec.BoundedInt.in_bounds", "FStar.Pervasives.Native.uu___is_Some", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "LowParse.Low.Base.Spec.gaccessor'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Low.Base.Spec.clens_id" ]	[]	false	false	false	false	false	let gaccessor_bounded_vldata_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) =	fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz	false
Vale.Stdcalls.X64.GCMdecryptOpt.fst	Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_lemma'	val gcm128_lemma' (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) (code: V.va_code) (_win: bool) (auth_b: b128) (auth_bytes auth_num: uint64) (keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128) (len128x6_num: uint64) (in128_b out128_b: b128) (len128_num: uint64) (inout_b: b128) (cipher_num: uint64) (scratch_b tag_b: b128) (va_s0: V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b)))	val gcm128_lemma' (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) (code: V.va_code) (_win: bool) (auth_b: b128) (auth_bytes auth_num: uint64) (keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128) (len128x6_num: uint64) (in128_b out128_b: b128) (len128_num: uint64) (inout_b: b128) (cipher_num: uint64) (scratch_b tag_b: b128) (va_s0: V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b)))	let gcm128_lemma' (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (code:V.va_code) (_win:bool) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b) )) = let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f	{ "file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCMdecryptOpt.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }	{ "end_col": 11, "end_line": 196, "start_col": 0, "start_line": 128 }	module Vale.Stdcalls.X64.GCMdecryptOpt open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open FStar.Mul module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s module GC = Vale.AES.X64.GCMdecryptOpt open Vale.AES.AES_s open Vale.AES.GCM_s let uint64 = UInt64.t (* A little utility to trigger normalization in types ) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let b128 = buf_t TUInt8 TUInt128 [@__reduce__] noextract let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq [@__reduce__] noextract let t128_mod_pub = TD_Buffer TUInt8 TUInt128 ({modified=true; strict_disjointness=false; taint=MS.Public}) [@__reduce__] noextract let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret}) [@__reduce__] noextract let tuint64 = TD_Base TUInt64 [@__reduce__] noextract let (dom: list td{List.length dom <= 20}) = let y = [t128_no_mod; tuint64; tuint64; t128_no_mod; t128_mod_pub; t128_no_mod; t128_no_mod; t128_no_mod; t128_mod; tuint64; t128_no_mod; t128_mod; tuint64; t128_mod; tuint64; t128_mod; t128_no_mod] in assert_norm (List.length y = 17); y ( Need to rearrange the order of arguments *) [@__reduce__] noextract let gcm128_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) -> GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) [@__reduce__] noextract let gcm128_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom = fun (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) (c:V.va_code) (auth_b:b128) (auth_bytes:uint64) (auth_num:uint64) (keys_b:b128) (iv_b:b128) (hkeys_b:b128) (abytes_b:b128) (in128x6_b:b128) (out128x6_b:b128) (len128x6_num:uint64) (in128_b:b128) (out128_b:b128) (len128_num:uint64) (inout_b:b128) (cipher_num:uint64) (scratch_b:b128) (tag_b:b128) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) va_s1 f #set-options "--z3rlimit 100"	{ "checked_file": "/", "dependencies": [ "Vale.X64.State.fsti.checked", "Vale.X64.MemoryAdapters.fsti.checked", "Vale.X64.Memory.fsti.checked", "Vale.X64.Machine_s.fst.checked", "Vale.X64.Decls.fsti.checked", "Vale.Interop.X64.fsti.checked", "Vale.Interop.Base.fst.checked", "Vale.Interop.Assumptions.fst.checked", "Vale.Def.Types_s.fst.checked", "Vale.AsLowStar.Wrapper.fsti.checked", "Vale.AsLowStar.ValeSig.fst.checked", "Vale.AsLowStar.MemoryHelpers.fsti.checked", "Vale.AsLowStar.LowStarSig.fst.checked", "Vale.AES.X64.GCMdecryptOpt.fsti.checked", "Vale.AES.GCM_s.fst.checked", "Vale.AES.AES_s.fst.checked", "prims.fst.checked", "LowStar.BufferView.Up.fsti.checked", "LowStar.BufferView.Down.fsti.checked", "LowStar.Buffer.fst.checked", "FStar.UInt64.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.List.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": false, "source_file": "Vale.Stdcalls.X64.GCMdecryptOpt.fst" }	[ { "abbrev": false, "full_module": "Vale.AES.GCM_s", "short_module": null }, { "abbrev": false, "full_module": "Vale.AES.AES_s", "short_module": null }, { "abbrev": true, "full_module": "Vale.AES.X64.GCMdecryptOpt", "short_module": "GC" }, { "abbrev": true, "full_module": "Vale.X64.Machine_s", "short_module": "MS" }, { "abbrev": true, "full_module": "Vale.X64.State", "short_module": "VS" }, { "abbrev": false, "full_module": "Vale.X64.MemoryAdapters", "short_module": null }, { "abbrev": true, "full_module": "Vale.AsLowStar.Wrapper", "short_module": "W" }, { "abbrev": true, "full_module": "Vale.Interop.Assumptions", "short_module": "IA" }, { "abbrev": true, "full_module": "Vale.X64.Decls", "short_module": "V" }, { "abbrev": true, "full_module": "Vale.X64.Memory", "short_module": "ME" }, { "abbrev": true, "full_module": "Vale.AsLowStar.LowStarSig", "short_module": "LSig" }, { "abbrev": true, "full_module": "Vale.AsLowStar.ValeSig", "short_module": "VSig" }, { "abbrev": true, "full_module": "Vale.Interop.X64", "short_module": "IX64" }, { "abbrev": false, "full_module": "Vale.Interop.Base", "short_module": null }, { "abbrev": false, "full_module": "Vale.Def.Types_s", "short_module": null }, { "abbrev": true, "full_module": "LowStar.BufferView.Up", "short_module": "UV" }, { "abbrev": true, "full_module": "LowStar.BufferView.Down", "short_module": "DV" }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "FStar.HyperStack.ST", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "short_module": null }, { "abbrev": false, "full_module": "Vale.Stdcalls.X64", "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 } ]	{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 0, "max_fuel": 1, "max_ifuel": 1, "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": true, "smtencoding_l_arith_repr": "native", "smtencoding_nl_arith_repr": "wrapped", "smtencoding_valid_elim": false, "smtencoding_valid_intro": true, "tcnorm": true, "trivial_pre_for_unannotated_effectful_fns": false, "z3cliopt": [ "smt.arith.nl=false", "smt.QI.EAGER_THRESHOLD=100", "smt.CASE_SPLIT=3" ], "z3refresh": false, "z3rlimit": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) -> iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE -> code: Vale.X64.Decls.va_code -> _win: Prims.bool -> auth_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> auth_bytes: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 -> auth_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 -> keys_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> iv_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> hkeys_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> abytes_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> in128x6_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> out128x6_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> len128x6_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 -> in128_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> out128_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> len128_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 -> inout_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> cipher_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 -> scratch_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> tag_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 -> va_s0: Vale.X64.Decls.va_state -> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel)	Prims.Ghost	[]	[]	[ "FStar.Ghost.erased", "FStar.Seq.Base.seq", "Vale.Def.Types_s.nat32", "Vale.AES.GCM_s.supported_iv_LE", "Vale.X64.Decls.va_code", "Prims.bool", "Vale.Stdcalls.X64.GCMdecryptOpt.b128", "Vale.Stdcalls.X64.GCMdecryptOpt.uint64", "Vale.X64.Decls.va_state", "Vale.X64.Decls.va_fuel", "FStar.Pervasives.Native.Mktuple2", "Prims.unit", "Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal", "Vale.Arch.HeapTypes_s.TUInt8", "Vale.Arch.HeapTypes_s.TUInt128", "FStar.Pervasives.Native.tuple2", "Vale.X64.State.vale_state", "Vale.AES.X64.GCMdecryptOpt.va_lemma_Gcm_blocks_decrypt_stdcall", "Vale.Interop.Assumptions.win", "Vale.AES.AES_common_s.AES_128", "Vale.X64.MemoryAdapters.as_vale_buffer", "FStar.UInt64.v", "FStar.Ghost.reveal", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_pre", "Prims.l_and", "Vale.X64.Decls.eval_code", "Vale.AsLowStar.ValeSig.vale_calling_conventions_stdcall", "Vale.Stdcalls.X64.GCMdecryptOpt.gcm128_post", "Vale.X64.Memory.buffer_writeable" ]	[]	false	false	false	false	false	let gcm128_lemma' (s: Ghost.erased (Seq.seq nat32)) (iv: Ghost.erased supported_iv_LE) (code: V.va_code) (_win: bool) (auth_b: b128) (auth_bytes auth_num: uint64) (keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128) (len128x6_num: uint64) (in128_b out128_b: b128) (len128_num: uint64) (inout_b: b128) (cipher_num: uint64) (scratch_b tag_b: b128) (va_s0: V.va_state) : Ghost (V.va_state & V.va_fuel) (requires gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\ ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\ ME.buffer_writeable (as_vale_buffer hkeys_b) /\ ME.buffer_writeable (as_vale_buffer abytes_b) /\ ME.buffer_writeable (as_vale_buffer in128x6_b) /\ ME.buffer_writeable (as_vale_buffer out128x6_b) /\ ME.buffer_writeable (as_vale_buffer in128_b) /\ ME.buffer_writeable (as_vale_buffer out128_b) /\ ME.buffer_writeable (as_vale_buffer inout_b) /\ ME.buffer_writeable (as_vale_buffer scratch_b) /\ ME.buffer_writeable (as_vale_buffer tag_b))) =	let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128 (as_vale_buffer auth_b) (UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b) (as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b) (as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num) (as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s) in Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b; Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b; va_s1, f	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.accessor_bounded_vldata_payload	val accessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_payload min max p))	val accessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_payload min max p))	let accessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` U32.uint_to_t (log256' max)	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 43, "end_line": 769, "start_col": 0, "start_line": 758 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.accessor (LowParse.Low.VLData.gaccessor_bounded_vldata_payload min max p)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.log256'", "Prims.unit", "LowParse.Low.Base.Spec.slice_access_eq", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Low.Base.Spec.clens_id", "LowParse.Low.VLData.gaccessor_bounded_vldata_payload", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.Base.accessor" ]	[]	false	false	false	false	false	let accessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) =	fun #rrel #rel input pos -> let h = HST.get () in [@@ inline_let ]let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` (U32.uint_to_t (log256' max))	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.finalize_bounded_vldata_strong	val finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos'))	val finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos'))	let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 63, "end_line": 565, "start_col": 0, "start_line": 528 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.finalize_bounded_vldata_strong_exact", "Prims.unit", "LowParse.Low.Base.Spec.valid_pos_valid_exact", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_pos", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "Prims.l_or", "FStar.Seq.Base.length", "LowParse.Spec.Base.serialize", "LowParse.Low.Base.Spec.contents", "FStar.UInt32.sub", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "LowParse.Spec.VLData.parse_bounded_vldata_strong_pred", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong" ]	[]	false	true	false	false	false	let finalize_bounded_vldata_strong (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ (let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)))))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` (U32.uint_to_t sz)) in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos')) =	let h = HST.get () in [@@ inline_let ]let _ = let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos'	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.finalize_bounded_vldata_exact	val finalize_bounded_vldata_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos'))	val finalize_bounded_vldata_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos'))	let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 55, "end_line": 602, "start_col": 0, "start_line": 568 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.unit	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "LowParse.Low.VLData.valid_bounded_vldata_intro", "Prims.unit", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.BoundedInt.write_bounded_integer", "FStar.UInt32.sub", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Spec.BoundedInt.log256'", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Pervasives.Native.uu___is_Some", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high", "FStar.Pervasives.Native.__proj__Some__item__v", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Low.Base.Spec.contents_exact" ]	[]	false	true	false	false	false	let finalize_bounded_vldata_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos')) =	[@@ inline_let ]let sz = log256' max in [@@ inline_let ]let len_payload = pos' `U32.sub` (pos `U32.add` (U32.uint_to_t sz)) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos'	false
LowParse.Low.Array.fst	LowParse.Low.Array.array_nth_ghost'	val array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))	val array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))	let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 58, "end_line": 146, "start_col": 0, "start_line": 130 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> elem_count: Prims.nat -> i: Prims.nat { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count } -> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Array.parse_array s array_byte_size elem_count ) p (LowParse.Low.Array.clens_array_nth t elem_count i)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.b2t", "Prims.op_LessThan", "LowParse.Bytes.bytes", "LowParse.Low.Array.array_nth_ghost''", "Prims.unit", "LowParse.Low.Array.array_nth_ghost_correct", "LowParse.Low.Base.Spec.gaccessor'", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "LowParse.Low.Array.clens_array_nth" ]	[]	false	false	false	false	false	let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) =	fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.gaccessor_bounded_vldata_strong_payload'	val gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s))	val gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s))	let gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) = fun input -> (gaccessor_bounded_vldata_payload min max p input <: (res : _ { gaccessor_post' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) input res } ))	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 186, "end_line": 794, "start_col": 0, "start_line": 785 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p inline_for_extraction let accessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` U32.uint_to_t (log256' max) let clens_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t) = { clens_cond = (fun _ -> True); clens_get = (fun (x: parse_bounded_vldata_strong_t min max s) -> (x <: t)); }	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) p (LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Bytes.bytes", "LowParse.Low.VLData.gaccessor_bounded_vldata_payload", "LowParse.Low.Base.Spec.gaccessor_post'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.VLData.clens_bounded_vldata_strong_payload", "LowParse.Low.Base.Spec.gaccessor'" ]	[]	false	false	false	false	false	let gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) =	fun input -> (gaccessor_bounded_vldata_payload min max p input <: (res: _ { gaccessor_post' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) input res }))	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.weak_finalize_bounded_vldata_strong_exact	val weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True)))	val weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True)))	let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 5, "end_line": 674, "start_col": 0, "start_line": 636 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.HyperStack.ST.Stack Prims.bool	FStar.HyperStack.ST.Stack	[]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "Prims.op_BarBar", "FStar.UInt32.lt", "FStar.UInt32.uint_to_t", "Prims.bool", "Prims.unit", "LowParse.Low.VLData.finalize_bounded_vldata_strong_exact", "FStar.UInt32.sub", "FStar.UInt32.add", "LowParse.Spec.BoundedInt.log256'", "FStar.Monotonic.HyperStack.mem", "Prims.op_Addition", "FStar.UInt32.v", "LowParse.Slice.__proj__Mkslice__item__len", "LowParse.Low.Base.writable", "LowParse.Slice.buffer_srel_of_srel", "LowParse.Slice.__proj__Mkslice__item__base", "LowParse.Low.Base.Spec.valid_exact", "LowParse.Spec.BoundedInt.integer_size", "LowStar.Monotonic.Buffer.modifies", "LowParse.Slice.loc_slice_from_to", "Prims.l_iff", "Prims.eq2", "LowParse.Spec.VLData.parse_bounded_vldata_strong_pred", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.Base.Spec.contents_exact", "Prims.l_True", "Prims.logical" ]	[]	false	true	false	false	false	let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ (let pos_payload = pos `U32.add` (U32.uint_to_t sz) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos'))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` (U32.uint_to_t sz) in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True))) =	let len_payload = pos' `U32.sub` (pos `U32.add` (U32.uint_to_t (log256' max))) in if (U32.uint_to_t max) `U32.lt` len_payload \|\| len_payload `U32.lt` (U32.uint_to_t min) then false else (finalize_bounded_vldata_strong_exact min max s input pos pos'; true)	false
LowParse.Low.Array.fst	LowParse.Low.Array.valid_list_valid_array	val valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'))	val valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'))	let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 68, "end_line": 267, "start_col": 0, "start_line": 240 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u218: u229: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> h: FStar.Monotonic.HyperStack.mem -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_list p h input pos pos' /\ (FStar.List.Tot.Base.length (LowParse.Low.Base.Spec.contents_list p h input pos pos') == elem_count \/ FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size)) (ensures (let x = LowParse.Low.Base.Spec.contents_list p h input pos pos' in FStar.List.Tot.Base.length x == elem_count /\ FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size /\ LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Array.parse_array s array_byte_size elem_count) h input pos x pos'))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "FStar.Monotonic.HyperStack.mem", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "LowParse.Spec.Array.parse_array_kind'", "LowParse.Spec.Array.parse_array'", "LowParse.Low.Array.valid_list_valid_array'", "LowParse.Low.Base.Spec.valid_list", "FStar.List.Tot.Base.length", "LowParse.Low.Base.Spec.contents_list", "Prims.op_Subtraction", "Prims.squash", "LowParse.Low.Base.Spec.valid_content_pos", "Prims.list", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos')) =	valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos'; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos	false
LowParse.Low.Array.fst	LowParse.Low.Array.jump_array	val jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count))	val jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count))	let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 84, "end_line": 390, "start_col": 0, "start_line": 377 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u348: u349: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> LowParse.Low.Base.jumper (LowParse.Spec.Array.parse_array s array_byte_size elem_count)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "LowParse.Low.Base.jump_constant_size", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "LowParse.Low.Base.jumper" ]	[]	false	false	false	false	false	let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) =	jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.gaccessor_bounded_vldata_payload	val gaccessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t))	val gaccessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t))	let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 45, "end_line": 755, "start_col": 0, "start_line": 744 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> p: LowParse.Spec.Base.parser k t { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.VLData.parse_bounded_vldata min max p) p (LowParse.Low.Base.Spec.clens_id t)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Low.VLData.gaccessor_bounded_vldata_payload'", "Prims.unit", "LowParse.Low.Base.Spec.gaccessor_prop_equiv", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Low.Base.Spec.clens_id", "Prims._assert", "Prims.l_Forall", "FStar.Seq.Base.seq", "LowParse.Bytes.byte", "Prims.l_imp", "LowParse.Low.Base.Spec.gaccessor_pre", "Prims.op_GreaterThanOrEqual", "FStar.Seq.Base.length", "FStar.Classical.forall_intro", "LowParse.Bytes.bytes", "LowParse.Spec.Base.parse", "LowParse.Spec.BoundedInt.bounded_integer", "LowParse.Spec.BoundedInt.parse_bounded_integer", "FStar.Pervasives.Native.tuple2", "LowParse.Spec.Base.consumed_length", "LowParse.Spec.VLData.parse_vldata_gen", "LowParse.Spec.BoundedInt.in_bounds", "FStar.Pervasives.Native.None", "Prims.l_or", "Prims.op_Addition", "FStar.UInt32.v", "Prims.bool", "FStar.Seq.Base.slice", "Prims.op_Equality", "Prims.int", "FStar.UInt.size", "FStar.UInt32.n", "FStar.Pervasives.Native.Mktuple2", "Prims.logical", "LowParse.Spec.VLData.parse_vldata_gen_eq", "LowParse.Spec.BoundedInt.integer_size", "LowParse.Low.Base.Spec.gaccessor" ]	[]	false	false	false	false	false	let gaccessor_bounded_vldata_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (p: parser k t {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) =	let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x. gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p	false
LowParse.Low.Array.fst	LowParse.Low.Array.validate_array'	val validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count))	val validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count))	let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) ()	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 355, "start_col": 0, "start_line": 338 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> v: LowParse.Low.Base.validator p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u315: u316: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> LowParse.Low.Base.validator (LowParse.Spec.Array.parse_array' s array_byte_size elem_count)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.validator", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "LowParse.Low.Combinators.validate_synth", "LowParse.Spec.FLData.parse_fldata_kind", "LowParse.Spec.List.parse_list_kind", "LowParse.Spec.FLData.parse_fldata_strong_t", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Spec.List.serialize_list", "LowParse.Spec.Array.array", "LowParse.Spec.FLData.parse_fldata_strong", "LowParse.Low.FLData.validate_fldata_strong", "LowParse.Low.List.validate_list", "LowParse.Spec.Array.fldata_to_array", "LowParse.Spec.Array.parse_array_kind'", "LowParse.Spec.Array.parse_array'" ]	[]	false	false	false	false	false	let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) =	validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) ()	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.gaccessor_bounded_vldata_strong_payload	val gaccessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s))	val gaccessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s))	let gaccessor_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) = gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_prop_equiv (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vldata_strong_payload' min max s); gaccessor_bounded_vldata_strong_payload' min max s	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 52, "end_line": 806, "start_col": 0, "start_line": 796 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p inline_for_extraction let accessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` U32.uint_to_t (log256' max) let clens_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t) = { clens_cond = (fun _ -> True); clens_get = (fun (x: parse_bounded_vldata_strong_t min max s) -> (x <: t)); } let gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) = fun input -> (gaccessor_bounded_vldata_payload min max p input <: (res : _ { gaccessor_post' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) input res } ))	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.VLData.parse_bounded_vldata_strong min max s) p (LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Low.VLData.gaccessor_bounded_vldata_strong_payload'", "Prims.unit", "LowParse.Low.Base.Spec.gaccessor_prop_equiv", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.BoundedInt.log256'", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.VLData.clens_bounded_vldata_strong_payload", "LowParse.Spec.VLData.parse_bounded_vldata", "LowParse.Low.Base.Spec.clens_id", "LowParse.Low.VLData.gaccessor_bounded_vldata_payload'", "LowParse.Low.Base.Spec.gaccessor" ]	[]	false	false	false	false	false	let gaccessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) =	gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_prop_equiv (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vldata_strong_payload' min max s); gaccessor_bounded_vldata_strong_payload' min max s	false
LowParse.Low.Array.fst	LowParse.Low.Array.array_nth_ghost	val array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))	val array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))	let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 49, "end_line": 171, "start_col": 0, "start_line": 149 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> elem_count: Prims.nat -> i: Prims.nat { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count } -> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Array.parse_array s array_byte_size elem_count) p (LowParse.Low.Array.clens_array_nth t elem_count i)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.b2t", "Prims.op_LessThan", "LowParse.Low.Array.array_nth_ghost'", "Prims.unit", "LowParse.Low.Base.Spec.gaccessor_prop_equiv", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "LowParse.Low.Array.clens_array_nth", "Prims._assert", "Prims.l_Forall", "FStar.Seq.Base.seq", "LowParse.Bytes.byte", "Prims.l_imp", "LowParse.Low.Base.Spec.gaccessor_pre", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "Prims.op_Multiply", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Seq.Base.length", "LowParse.Spec.Base.parser_kind_prop_equiv", "LowParse.Spec.Array.parse_array_kind'", "FStar.Math.Lemmas.lemma_mult_le_right", "FStar.Math.Lemmas.distributivity_add_left", "FStar.Pervasives.reveal_opaque", "LowParse.Bytes.bytes", "LowParse.Low.Array.array_nth_ghost''", "LowParse.Low.Base.Spec.gaccessor'", "LowParse.Low.Base.Spec.gaccessor" ]	[]	false	false	false	false	false	let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) =	reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x. gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i	false
LowParse.Low.Array.fst	LowParse.Low.Array.valid_array_valid_list	val valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x))	val valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x))	let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 86, "end_line": 335, "start_col": 0, "start_line": 305 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos'	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u296: u308: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> h: FStar.Monotonic.HyperStack.mem -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.Array.parse_array s array_byte_size elem_count) h input pos) (ensures (let pos' = LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Array.parse_array s array_byte_size elem_count) h input pos in let x = LowParse.Low.Base.Spec.contents (LowParse.Spec.Array.parse_array s array_byte_size elem_count) h input pos in FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size /\ LowParse.Low.Base.Spec.valid_list p h input pos pos' /\ LowParse.Low.Base.Spec.contents_list p h input pos pos' == x))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "FStar.Monotonic.HyperStack.mem", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "LowParse.Low.Array.valid_array_valid_list'", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.Array.parse_array_kind'", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array'", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.parse_array", "LowParse.Low.Base.Spec.valid", "Prims.squash", "Prims.op_Subtraction", "LowParse.Low.Base.Spec.valid_list", "Prims.list", "LowParse.Low.Base.Spec.contents_list", "LowParse.Low.Base.Spec.contents", "LowParse.Low.Base.Spec.get_valid_pos", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x)) =	valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos	false
LowParse.Low.Array.fst	LowParse.Low.Array.array_nth_ghost_correct	val array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))	val array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))	let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 89, "end_line": 127, "start_col": 0, "start_line": 110 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> elem_count: Prims.nat -> i: Prims.nat { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count } -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Low.Base.Spec.gaccessor_post' (LowParse.Spec.Array.parse_array s array_byte_size elem_count) p (LowParse.Low.Array.clens_array_nth t elem_count i) input (LowParse.Low.Array.array_nth_ghost'' s array_byte_size elem_count i input))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.b2t", "Prims.op_LessThan", "LowParse.Bytes.bytes", "FStar.Classical.move_requires", "LowParse.Low.Base.Spec.gaccessor_pre", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "LowParse.Low.Array.clens_array_nth", "LowParse.Low.Base.Spec.gaccessor_post'", "LowParse.Low.Array.array_nth_ghost''", "LowParse.Low.Array.array_nth_ghost_correct'", "Prims.unit", "FStar.Pervasives.reveal_opaque", "Prims.l_True", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	false	false	true	false	false	let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) =	reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.compare_namedv	val compare_namedv (v1 v2: namedv) : order	val compare_namedv (v1 v2: namedv) : order	let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 69, "end_line": 35, "start_col": 0, "start_line": 34 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	v1: FStar.Stubs.Reflection.Types.namedv -> v2: FStar.Stubs.Reflection.Types.namedv -> FStar.Order.order	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.namedv", "FStar.Order.compare_int", "FStar.Stubs.Reflection.V2.Data.__proj__Mknamedv_view__item__uniq", "FStar.Stubs.Reflection.V2.Builtins.inspect_namedv", "FStar.Order.order" ]	[]	false	false	false	true	false	let compare_namedv (v1 v2: namedv) : order =	Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq	false
LowParse.Low.VLData.fst	LowParse.Low.VLData.accessor_bounded_vldata_strong_payload	val accessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_strong_payload min max s))	val accessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_strong_payload min max s))	let accessor_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_strong_payload min max s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_strong_payload min max s) input pos in pos `U32.add` U32.uint_to_t (log256' max)	{ "file_name": "src/lowparse/LowParse.Low.VLData.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 43, "end_line": 821, "start_col": 0, "start_line": 809 }	module LowParse.Low.VLData include LowParse.Spec.VLData include LowParse.Low.BoundedInt // for bounded_integer include LowParse.Low.FLData module B = LowStar.Buffer module HST = FStar.HyperStack.ST module U32 = FStar.UInt32 inline_for_extraction let validate_vldata_payload (sz: integer_size) (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (i: bounded_integer sz { f i == true } ) : Tot (validator (parse_vldata_payload sz f p i)) = validate_weaken (parse_vldata_payload_kind sz k) (validate_fldata v (U32.v i) i) () inline_for_extraction let validate_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (f' : ((x: bounded_integer sz) -> Tot (y: bool { y == f x }))) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_vldata_gen sz f p)) = parse_vldata_gen_eq_def sz f p; validate_filter_and_then (validate_bounded_integer sz) (read_bounded_integer sz) f f' #_ #_ #(parse_vldata_payload sz f p) (validate_vldata_payload sz f v) () #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" module HS = FStar.HyperStack let valid_vldata_gen_elim (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_vldata_gen sz f p) h input pos )) (ensures ( valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in f len_payload == true /\ sz + U32.v len_payload == content_length (parse_vldata_gen sz f p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_vldata_gen sz f p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_vldata_gen sz f p) h input pos )))) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); let len_payload = contents (parse_bounded_integer sz) h input pos in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact_equiv p h input pos_payload (pos_payload `U32.add` len_payload); contents_exact_eq p h input pos_payload (pos_payload `U32.add` len_payload) #pop-options inline_for_extraction let jump_vldata_gen (sz: integer_size) // must be a constant (f: ((x: bounded_integer sz) -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_vldata_gen sz f p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_vldata_gen_elim h sz f p input pos in pos `U32.add` (U32.uint_to_t sz `U32.add` read_bounded_integer sz input pos) inline_for_extraction let validate_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) : Tot (validator (parse_bounded_vldata' min max l p)) = [@inline_let] let sz : integer_size = l in [@inline_let] let _ = parse_bounded_vldata_correct min max sz p in validate_strengthen (parse_bounded_vldata_strong_kind min max sz k) (validate_vldata_gen sz (in_bounds min max) (fun i -> if min = 0 then i `U32.lte` U32.uint_to_t max else (U32.uint_to_t min `U32.lte` i && i `U32.lte` U32.uint_to_t max)) v) () inline_for_extraction let validate_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (#p: parser k t) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata min max p)) = validate_bounded_vldata' min max (log256' max) v inline_for_extraction let jump_bounded_vldata' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) // must be a constant (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (jumper (parse_bounded_vldata' min max l p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let sz = l in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in [@inline_let] let _ = valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos in jump_vldata_gen sz (in_bounds min max) p input pos inline_for_extraction let jump_bounded_vldata (min: nat) // must be a constant (max: nat) // must be a constant (#k: parser_kind) (#t: Type) (p: parser k t) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata min max p)) = jump_bounded_vldata' min max (log256' max) p inline_for_extraction let validate_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) : Tot (validator (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input (uint64_to_uint32 pos) in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input (uint64_to_uint32 pos) in validate_bounded_vldata' min max l v input pos inline_for_extraction let validate_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (validator (parse_bounded_vldata_strong min max s)) = validate_bounded_vldata_strong' min max (log256' max) s v inline_for_extraction let jump_bounded_vldata_strong' (min: nat) // must be a constant (max: nat { min <= max /\ max > 0 /\ max < 4294967296 }) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (jumper (parse_bounded_vldata_strong' min max l s)) = fun #rrel #rel (input: slice rrel rel) pos -> let h = HST.get () in [@inline_let] let _ = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos in [@inline_let] let _ = valid_facts (parse_bounded_vldata' min max l p) h input pos in jump_bounded_vldata' min max l p input pos inline_for_extraction let jump_bounded_vldata_strong (min: nat) // must be a constant (max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (u: unit { min <= max /\ max > 0 /\ max < 4294967296 }) : Tot (jumper (parse_bounded_vldata_strong min max s)) = jump_bounded_vldata_strong' min max (log256' max) s #push-options "--z3rlimit 32 --initial_ifuel 4 --max_ifuel 4" let valid_vldata_gen_intro (h: HS.mem) (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ f len_payload == true /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( valid_content_pos (parse_vldata_gen sz f p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_vldata_gen sz f p) h input pos; valid_facts (parse_bounded_integer sz) h input pos; parse_vldata_gen_eq sz f p (bytes_of_slice_from h input pos); contents_exact_eq p h input (pos `U32.add` U32.uint_to_t sz) pos' #pop-options inline_for_extraction let finalize_vldata_gen (sz: integer_size) (f: (bounded_integer sz -> GTot bool)) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in bounded_integer_prop sz len_payload /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ f len_payload == true )))) (ensures (fun h _ h' -> B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_vldata_gen sz f p) h' input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_vldata_gen_intro h sz f p input pos pos' let valid_bounded_vldata'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata' min max l p) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata' min max l p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata' min max l p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata' min max l p) h input pos )))) = valid_facts (parse_bounded_vldata' min max l p) h input pos; let sz = l in valid_facts (parse_vldata_gen sz (in_bounds min max) p) h input pos; valid_vldata_gen_elim h sz (in_bounds min max) p input pos let valid_bounded_vldata_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata min max p) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata min max p) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata min max p) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata min max p) h input pos )))) = valid_bounded_vldata'_elim h min max (log256' max) p input pos let valid_bounded_vldata_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in valid_content_pos (parse_bounded_vldata min max p) h input pos (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos') pos' )) = valid_facts (parse_bounded_vldata min max p) h input pos; valid_facts (parse_vldata_gen (log256' max) (in_bounds min max) p) h input pos; valid_vldata_gen_intro h (log256' max) (in_bounds min max) p input pos pos' let valid_bounded_vldata_strong'_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (l: nat { l >= log256' max /\ l <= 4 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong' min max l s) h input pos )) (ensures ( let sz = l in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong' min max l s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong' min max l s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong' min max l s) h input pos )))) = valid_facts (parse_bounded_vldata_strong' min max l s) h input pos; valid_facts (parse_bounded_vldata' min max l p) h input pos; valid_bounded_vldata'_elim h min max l p input pos let valid_bounded_vldata_strong_elim (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_bounded_vldata_strong min max s) h input pos )) (ensures ( let sz = log256' max in valid (parse_bounded_integer sz) h input pos /\ ( let len_payload = contents (parse_bounded_integer sz) h input pos in min <= U32.v len_payload /\ U32.v len_payload <= max /\ sz + U32.v len_payload == content_length (parse_bounded_vldata_strong min max s) h input pos /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos (parse_bounded_vldata_strong min max s) h input pos (pos_payload `U32.add` len_payload) /\ valid_exact p h input pos_payload (pos_payload `U32.add` len_payload) /\ contents_exact p h input pos_payload (pos_payload `U32.add` len_payload) == contents (parse_bounded_vldata_strong min max s) h input pos )))) = valid_bounded_vldata_strong'_elim h min max (log256' max) s input pos let valid_bounded_vldata_strong_intro (h: HS.mem) (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires ( let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in min <= U32.v len_payload /\ U32.v len_payload <= max /\ valid (parse_bounded_integer sz) h input pos /\ contents (parse_bounded_integer sz) h input pos == len_payload )))) (ensures ( let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h input pos x pos' )) = valid_facts (parse_bounded_vldata_strong min max s) h input pos; valid_facts (parse_bounded_vldata min max p) h input pos; valid_bounded_vldata_intro h min max p input pos pos'; valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' inline_for_extraction let finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in [@inline_let] let _ = serialized_length_eq s (contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos'); valid_exact_serialize s h input (pos `U32.add` U32.uint_to_t sz) pos' in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_strong_intro h min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ ( let len_payload = pos' `U32.sub` pos_payload in let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in writable input.base (U32.v pos) (U32.v pos + sz) h /\ ((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max)) )))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' )) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in finalize_bounded_vldata_strong_exact min max s input pos pos' inline_for_extraction let finalize_bounded_vldata_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_exact p h input pos_payload pos' /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents_exact p h input (pos `U32.add` U32.uint_to_t sz) pos' in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = [@inline_let] let sz = log256' max in [@inline_let] let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t sz) in let h = HST.get () in let _ = write_bounded_integer sz len_payload input pos in let h = HST.get () in valid_bounded_vldata_intro h min max p input pos pos' inline_for_extraction let finalize_bounded_vldata (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack unit (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\ writable input.base (U32.v pos) (U32.v pos + sz) h /\ min <= k.parser_kind_low /\ Some? k.parser_kind_high /\ Some?.v k.parser_kind_high <= max ))) (ensures (fun h _ h' -> let sz = log256' max in let x = contents p h input (pos `U32.add` U32.uint_to_t sz) in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ valid_content_pos (parse_bounded_vldata min max p) h' input pos x pos' )) = finalize_bounded_vldata_exact min max p input pos pos' inline_for_extraction let weak_finalize_bounded_vldata_strong_exact (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_exact p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents_exact p h input pos_payload pos' in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let len_payload = pos' `U32.sub` (pos `U32.add` U32.uint_to_t (log256' max)) in if U32.uint_to_t max `U32.lt` len_payload \|\| len_payload `U32.lt` U32.uint_to_t min then false else begin finalize_bounded_vldata_strong_exact min max s input pos pos'; true end inline_for_extraction let weak_finalize_bounded_vldata_strong (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : HST.Stack bool (requires (fun h -> let sz = log256' max in U32.v pos + sz <= U32.v input.len /\ k.parser_kind_subkind == Some ParserStrong /\ ( let pos_payload = pos `U32.add` U32.uint_to_t sz in writable input.base (U32.v pos) (U32.v pos + sz) h /\ valid_pos p h input pos_payload pos' ))) (ensures (fun h res h' -> let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in let len_payload = pos' `U32.sub` pos_payload in B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\ (res == true <==> (min <= U32.v len_payload /\ U32.v len_payload <= max)) /\ (if res then let x = contents p h input pos_payload in parse_bounded_vldata_strong_pred min max s x /\ valid_content_pos (parse_bounded_vldata_strong min max s) h' input pos x pos' else True ))) = let h = HST.get () in [@inline_let] let _ = let sz = log256' max in let pos_payload = pos `U32.add` U32.uint_to_t sz in valid_pos_valid_exact p h input pos_payload pos' in weak_finalize_bounded_vldata_strong_exact min max s input pos pos' let gaccessor_bounded_vldata_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor' (parse_bounded_vldata min max p) p (clens_id t)) = fun input -> let sz = log256' max in parse_vldata_gen_eq sz (in_bounds min max) p input; if Seq.length input < sz then 0 (* dummy *) else let _ = match parse (parse_bounded_vldata min max p) input with \| None -> () \| Some _ -> assert (Some? (parse (parse_vldata_gen sz (in_bounds min max) p) input)); parse_vldata_gen_eq sz (in_bounds min max) p input; let Some (len, consumed) = parse (parse_bounded_integer sz) input in assert (consumed == sz); parse_strong_prefix p (Seq.slice input sz (sz + U32.v len)) (Seq.slice input sz (Seq.length input)) in sz let gaccessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (gaccessor (parse_bounded_vldata min max p) p (clens_id t)) = let sz = log256' max in Classical.forall_intro (parse_vldata_gen_eq sz (in_bounds min max) p); assert (forall x . gaccessor_pre (parse_bounded_vldata min max p) p (clens_id t) x ==> Seq.length x >= sz); gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_bounded_vldata_payload' min max p inline_for_extraction let accessor_bounded_vldata_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (p: parser k t { k.parser_kind_subkind == Some ParserStrong }) : Tot (accessor (gaccessor_bounded_vldata_payload min max p)) = fun #rrel #rel input pos -> let h = HST.get () in [@inline_let] let _ = slice_access_eq h (gaccessor_bounded_vldata_payload min max p) input pos in pos `U32.add` U32.uint_to_t (log256' max) let clens_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Tot (clens (parse_bounded_vldata_strong_t min max s) t) = { clens_cond = (fun _ -> True); clens_get = (fun (x: parse_bounded_vldata_strong_t min max s) -> (x <: t)); } let gaccessor_bounded_vldata_strong_payload' (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) = fun input -> (gaccessor_bounded_vldata_payload min max p input <: (res : _ { gaccessor_post' (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) input res } )) let gaccessor_bounded_vldata_strong_payload (min: nat) (max: nat { min <= max /\ max > 0 /\ max < 4294967296 } ) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (gaccessor (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s)) = gaccessor_prop_equiv (parse_bounded_vldata min max p) p (clens_id t) (gaccessor_bounded_vldata_payload' min max p); gaccessor_prop_equiv (parse_bounded_vldata_strong min max s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vldata_strong_payload' min max s); gaccessor_bounded_vldata_strong_payload' min max s	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.VLData.fsti.checked", "LowParse.Low.FLData.fst.checked", "LowParse.Low.BoundedInt.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.VLData.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": false, "full_module": "LowParse.Low.FLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.BoundedInt", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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" }	false	min: Prims.nat -> max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} -> s: LowParse.Spec.Base.serializer p { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> LowParse.Low.Base.accessor (LowParse.Low.VLData.gaccessor_bounded_vldata_strong_payload min max s)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_GreaterThan", "Prims.op_LessThan", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.eq2", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_subkind", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserStrong", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.t", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "LowParse.Spec.BoundedInt.log256'", "Prims.unit", "LowParse.Low.Base.Spec.slice_access_eq", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.VLData.clens_bounded_vldata_strong_payload", "LowParse.Low.VLData.gaccessor_bounded_vldata_strong_payload", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "LowParse.Low.Base.accessor" ]	[]	false	false	false	false	false	let accessor_bounded_vldata_strong_payload (min: nat) (max: nat{min <= max /\ max > 0 /\ max < 4294967296}) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) : Tot (accessor (gaccessor_bounded_vldata_strong_payload min max s)) =	fun #rrel #rel input pos -> let h = HST.get () in [@@ inline_let ]let _ = slice_access_eq h (gaccessor_bounded_vldata_strong_payload min max s) input pos in pos `U32.add` (U32.uint_to_t (log256' max))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.compare_bv	val compare_bv (v1 v2: bv) : order	val compare_bv (v1 v2: bv) : order	let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 63, "end_line": 32, "start_col": 0, "start_line": 31 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	v1: FStar.Stubs.Reflection.Types.bv -> v2: FStar.Stubs.Reflection.Types.bv -> FStar.Order.order	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.bv", "FStar.Order.compare_int", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbv_view__item__index", "FStar.Stubs.Reflection.V2.Builtins.inspect_bv", "FStar.Order.order" ]	[]	false	false	false	true	false	let compare_bv (v1 v2: bv) : order =	Order.compare_int (inspect_bv v1).index (inspect_bv v2).index	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.shift_subst		val shift_subst : n: Prims.int -> s: Prims.list FStar.Stubs.Syntax.Syntax.subst_elt -> Prims.list FStar.Stubs.Syntax.Syntax.subst_elt	let shift_subst n s = List.Tot.map (shift n) s	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 46, "end_line": 44, "start_col": 0, "start_line": 44 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	n: Prims.int -> s: Prims.list FStar.Stubs.Syntax.Syntax.subst_elt -> Prims.list FStar.Stubs.Syntax.Syntax.subst_elt	Prims.Tot	[ "total" ]	[]	[ "Prims.int", "Prims.list", "FStar.Stubs.Syntax.Syntax.subst_elt", "FStar.List.Tot.Base.map", "FStar.Reflection.V2.Derived.shift" ]	[]	false	false	false	true	false	let shift_subst n s =	List.Tot.map (shift n) s	false
LowParse.Low.Array.fst	LowParse.Low.Array.vlarray_nth_ghost''	val vlarray_nth_ghost'' (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (i: nat { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (input: bytes) : GTot (nat)	val vlarray_nth_ghost'' (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (i: nat { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (input: bytes) : GTot (nat)	let vlarray_nth_ghost'' (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (i: nat { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (input: bytes) : GTot (nat) = if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low)) else (0)	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 10, "end_line": 566, "start_col": 0, "start_line": 550 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u inline_for_extraction let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 () inline_for_extraction let validate_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } ) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let jump_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } ) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; jump_synth (jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let finalize_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (#rrel #rel: _) (sl: slice rrel rel) (pos pos' : U32.t) : HST.Stack unit (requires (fun h -> vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ ( let vpos1 = U32.v pos + log256' array_byte_size_max in vpos1 < 4294967296 /\ ( let pos1 = U32.uint_to_t vpos1 in let len = U32.v pos' - vpos1 in valid_list p h sl pos1 pos' /\ ( let count = L.length (contents_list p h sl pos1 pos') in writable sl.base (U32.v pos) vpos1 h /\ ((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max)) ))))) (ensures (fun h _ h' -> let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in let l = contents_list p h sl pos1 pos' in B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\ L.length l <= elem_count_max /\ valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos' )) = let h = HST.get () in let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in valid_list_valid_exact_list p h sl pos1 pos'; let l = Ghost.hide (contents_list p h sl pos1 pos') in let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) = valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ; Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l) in vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l); finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ; let h = HST.get () in valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos let clens_vlarray_nth (t: Type) (min max: nat) (i: nat) : Tot (clens (vlarray t min max) t) = { clens_cond = (fun (l: vlarray t min max) -> i < L.length l); clens_get = (fun (l: vlarray t min max) -> L.index l i); } inline_for_extraction let vlarray_list_length (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (#rrel #rel: _) (sl: slice rrel rel) (pos: U32.t) : HST.Stack U32.t (requires (fun h -> vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos )) (ensures (fun h res h' -> let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in B.modifies B.loc_none h h' /\ U32.v res == L.length x /\ U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\ valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\ contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x )) = let h = HST.get () in [@inline_let] let _ : unit = let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in let sq = bytes_of_slice_from h sl pos in valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos; valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos; vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (); parse_synth_eq (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sq; parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq; let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in let Some (ln, _) = psq in list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln)); LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low; let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in let pos' = pos_payload `U32.add` ln in valid_exact_equiv (parse_list p) h sl pos_payload pos'; contents_exact_eq (parse_list p) h sl pos_payload pos'; valid_exact_list_valid_list p h sl pos_payload pos' in [@inline_let] let klow : U32.t = U32.uint_to_t k.parser_kind_low in let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in blen `U32.div` klow #push-options "--z3rlimit 16"	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	array_byte_size_min: Prims.nat -> array_byte_size_max: Prims.nat -> s: LowParse.Spec.Base.serializer p -> elem_count_min: Prims.nat -> elem_count_max: Prims.nat -> i: Prims.nat { LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true } -> input: LowParse.Bytes.bytes -> Prims.GTot Prims.nat	Prims.GTot	[ "sometrivial" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.vldata_vlarray_precond", "LowParse.Bytes.bytes", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "LowParse.Spec.BoundedInt.log256'", "Prims.op_Multiply", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Seq.Base.length", "LowParse.Bytes.byte", "LowParse.Math.mult_nat" ]	[]	false	false	false	false	false	let vlarray_nth_ghost'' (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (i: nat { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (input: bytes) : GTot (nat) =	if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low)) else (0)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.subst1	val subst1 (n: namedv) (t1 t2: term) : term	val subst1 (n: namedv) (t1 t2: term) : term	let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 25, "end_line": 47, "start_col": 0, "start_line": 46 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	n: FStar.Stubs.Reflection.Types.namedv -> t1: FStar.Stubs.Reflection.Types.term -> t2: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.namedv", "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.subst_term", "Prims.Cons", "FStar.Stubs.Syntax.Syntax.subst_elt", "FStar.Stubs.Syntax.Syntax.NT", "Prims.Nil" ]	[]	false	false	false	true	false	let subst1 (n: namedv) (t1 t2: term) : term =	subst_term [NT n t1] t2	false
LowParse.Low.Array.fst	LowParse.Low.Array.validate_array	val validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count))	val validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count))	let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 73, "end_line": 374, "start_col": 0, "start_line": 358 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> v: LowParse.Low.Base.validator p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u333: u334: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> LowParse.Low.Base.validator (LowParse.Spec.Array.parse_array s array_byte_size elem_count)	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.validator", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "Prims.op_Equality", "FStar.Pervasives.Native.option", "LowParse.Spec.Base.parser_kind_metadata_some", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_metadata", "FStar.Pervasives.Native.Some", "LowParse.Spec.Base.ParserKindMetadataTotal", "LowParse.Low.Base.validate_total_constant_size", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.array", "LowParse.Spec.Array.parse_array", "FStar.Int.Cast.uint32_to_uint64", "LowParse.Low.Array.validate_array'" ]	[]	false	false	false	false	false	let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) =	if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.push_binding	val push_binding (e: env) (b: binding) : env	val push_binding (e: env) (b: binding) : env	let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 18, "end_line": 78, "start_col": 0, "start_line": 71 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? *) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; }	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	e: FStar.Stubs.Reflection.Types.env -> b: FStar.Stubs.Reflection.V2.Data.binding -> FStar.Stubs.Reflection.Types.env	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.env", "FStar.Stubs.Reflection.V2.Data.binding", "FStar.Stubs.Reflection.V2.Builtins.push_namedv", "FStar.Stubs.Reflection.Types.namedv", "FStar.Stubs.Reflection.V2.Builtins.pack_namedv", "FStar.Stubs.Reflection.V2.Data.Mknamedv_view", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinding__item__uniq", "FStar.Sealed.seal", "FStar.Stubs.Reflection.Types.typ", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinding__item__sort", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinding__item__ppname" ]	[]	false	false	false	true	false	let push_binding (e: env) (b: binding) : env =	let nv:namedv = pack_namedv ({ uniq = b.uniq; sort = seal b.sort; ppname = b.ppname }) in push_namedv e nv	false
LowParse.Low.Array.fst	LowParse.Low.Array.clens_vlarray_nth	val clens_vlarray_nth (t: Type) (min max i: nat) : Tot (clens (vlarray t min max) t)	val clens_vlarray_nth (t: Type) (min max i: nat) : Tot (clens (vlarray t min max) t)	let clens_vlarray_nth (t: Type) (min max: nat) (i: nat) : Tot (clens (vlarray t min max) t) = { clens_cond = (fun (l: vlarray t min max) -> i < L.length l); clens_get = (fun (l: vlarray t min max) -> L.index l i); }	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 1, "end_line": 488, "start_col": 0, "start_line": 480 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u inline_for_extraction let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 () inline_for_extraction let validate_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } ) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let jump_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } ) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; jump_synth (jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let finalize_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (#rrel #rel: _) (sl: slice rrel rel) (pos pos' : U32.t) : HST.Stack unit (requires (fun h -> vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ ( let vpos1 = U32.v pos + log256' array_byte_size_max in vpos1 < 4294967296 /\ ( let pos1 = U32.uint_to_t vpos1 in let len = U32.v pos' - vpos1 in valid_list p h sl pos1 pos' /\ ( let count = L.length (contents_list p h sl pos1 pos') in writable sl.base (U32.v pos) vpos1 h /\ ((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max)) ))))) (ensures (fun h _ h' -> let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in let l = contents_list p h sl pos1 pos' in B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\ L.length l <= elem_count_max /\ valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos' )) = let h = HST.get () in let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in valid_list_valid_exact_list p h sl pos1 pos'; let l = Ghost.hide (contents_list p h sl pos1 pos') in let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) = valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ; Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l) in vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l); finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ; let h = HST.get () in valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	t: Type -> min: Prims.nat -> max: Prims.nat -> i: Prims.nat -> LowParse.Low.Base.Spec.clens (LowParse.Spec.Array.vlarray t min max) t	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Low.Base.Spec.Mkclens", "LowParse.Spec.Array.vlarray", "Prims.b2t", "Prims.op_LessThan", "FStar.List.Tot.Base.length", "FStar.List.Tot.Base.index", "LowParse.Low.Base.Spec.clens" ]	[]	false	false	false	false	false	let clens_vlarray_nth (t: Type) (min max i: nat) : Tot (clens (vlarray t min max) t) =	{ clens_cond = (fun (l: vlarray t min max) -> i < L.length l); clens_get = (fun (l: vlarray t min max) -> L.index l i) }	false
LowParse.Low.Array.fst	LowParse.Low.Array.valid_list_valid_array'	val valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'))	val valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'))	let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 134, "end_line": 238, "start_col": 0, "start_line": 207 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u176: u187: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> h: FStar.Monotonic.HyperStack.mem -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> pos': FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_list p h input pos pos' /\ (FStar.List.Tot.Base.length (LowParse.Low.Base.Spec.contents_list p h input pos pos') == elem_count \/ FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size)) (ensures (let x = LowParse.Low.Base.Spec.contents_list p h input pos pos' in FStar.List.Tot.Base.length x == elem_count /\ FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size /\ LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Array.parse_array' s array_byte_size elem_count) h input pos x pos'))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "FStar.Monotonic.HyperStack.mem", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "LowParse.Low.Combinators.valid_synth", "LowParse.Spec.FLData.parse_fldata_kind", "LowParse.Spec.List.parse_list_kind", "LowParse.Spec.FLData.parse_fldata_strong_t", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Spec.List.serialize_list", "LowParse.Spec.Array.array", "LowParse.Spec.FLData.parse_fldata_strong", "LowParse.Spec.Array.fldata_to_array", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Low.Base.Spec.contents_exact_eq", "LowParse.Spec.List.list_length_constant_size_parser_correct", "FStar.Seq.Base.slice", "LowParse.Slice.bytes_of_slice_from", "FStar.UInt32.sub", "LowParse.Low.Base.Spec.valid_exact_equiv", "LowParse.Low.List.valid_list_valid_exact_list", "LowParse.Low.Base.Spec.valid_list", "FStar.List.Tot.Base.length", "LowParse.Low.Base.Spec.contents_list", "Prims.op_Subtraction", "Prims.squash", "LowParse.Low.Base.Spec.valid_content_pos", "LowParse.Spec.Array.parse_array_kind'", "LowParse.Spec.Array.parse_array'", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos': U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures (let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos')) =	valid_list_valid_exact_list p h input pos pos'; valid_exact_equiv (parse_list p) h input pos pos'; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.inspect_ln_unascribe	val inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv}	val inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv}	let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 14, "end_line": 29, "start_col": 0, "start_line": 25 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> tv: FStar.Stubs.Reflection.V2.Data.term_view {tv << t /\ FStar.Stubs.Reflection.V2.Data.notAscription tv}	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.inspect_ln", "FStar.Pervasives.Native.option", "Prims.bool", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Stubs.Reflection.Types.comp", "FStar.Stubs.Reflection.V2.Data.term_view", "Prims.l_and", "Prims.precedes", "Prims.b2t", "FStar.Stubs.Reflection.V2.Data.notAscription" ]	[ "recursion" ]	false	false	false	false	false	let rec inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv} =	match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv	false
LowParse.Low.Array.fst	LowParse.Low.Array.validate_vlarray	val validate_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296}) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))	val validate_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296}) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))	let validate_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } ) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) ()	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 412, "start_col": 0, "start_line": 393 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u inline_for_extraction let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	array_byte_size_min: Prims.nat -> array_byte_size_max: Prims.nat -> s: LowParse.Spec.Base.serializer p -> v: LowParse.Low.Base.validator p -> elem_count_min: Prims.nat -> elem_count_max: Prims.nat -> u372: u374: Prims.unit { LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true } -> sz32: FStar.UInt32.t { FStar.UInt32.v sz32 == LowParse.Spec.BoundedInt.log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } -> LowParse.Low.Base.validator (LowParse.Spec.Array.parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u372)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "LowParse.Low.Base.validator", "Prims.unit", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.vldata_vlarray_precond", "FStar.UInt32.t", "Prims.l_and", "Prims.int", "Prims.l_or", "FStar.UInt.size", "FStar.UInt32.n", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "Prims.op_LessThanOrEqual", "FStar.UInt32.v", "LowParse.Spec.BoundedInt.log256'", "Prims.op_LessThan", "LowParse.Low.Combinators.validate_synth", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.List.parse_list_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Spec.List.serialize_list", "LowParse.Spec.Array.vlarray", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.VLData.validate_bounded_vldata_strong", "LowParse.Low.List.validate_list", "LowParse.Spec.Array.vldata_to_vlarray", "LowParse.Spec.Array.vldata_to_vlarray_inj", "LowParse.Spec.Array.parse_vlarray_kind", "LowParse.Spec.Array.parse_vlarray" ]	[]	false	false	false	false	false	let validate_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296}) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) =	vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) ()	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.type_of_binder	val type_of_binder (b: binder) : typ	val type_of_binder (b: binder) : typ	let type_of_binder (b : binder) : typ = (inspect_binder b).sort	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 27, "end_line": 81, "start_col": 0, "start_line": 80 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? *) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	b: FStar.Stubs.Reflection.Types.binder -> FStar.Stubs.Reflection.Types.typ	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinder_view__item__sort", "FStar.Stubs.Reflection.V2.Builtins.inspect_binder", "FStar.Stubs.Reflection.Types.typ" ]	[]	false	false	false	true	false	let type_of_binder (b: binder) : typ =	(inspect_binder b).sort	false
LowParse.Low.Array.fst	LowParse.Low.Array.array_nth	val array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))	val array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))	let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 61, "end_line": 203, "start_col": 0, "start_line": 176 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> elem_count: Prims.nat -> i: FStar.UInt32.t { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ FStar.UInt32.v i < elem_count } -> LowParse.Low.Base.accessor (LowParse.Low.Array.array_nth_ghost s array_byte_size elem_count (FStar.UInt32.v i))	Prims.Tot	[ "total" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.b2t", "Prims.op_LessThan", "FStar.UInt32.v", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "FStar.UInt32.add", "FStar.UInt32.mul", "FStar.UInt32.uint_to_t", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "Prims.unit", "LowParse.Low.Array.list_nth_constant_size_parser_correct", "FStar.Seq.Base.slice", "LowParse.Slice.bytes_of_slice_from", "LowParse.Spec.Combinators.parse_synth_eq", "LowParse.Spec.FLData.parse_fldata_kind", "LowParse.Spec.List.parse_list_kind", "LowParse.Spec.FLData.parse_fldata_strong_t", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Spec.List.serialize_list", "LowParse.Spec.Array.array", "LowParse.Spec.FLData.parse_fldata_strong", "LowParse.Spec.Array.fldata_to_array", "LowParse.Spec.Array.fldata_to_array_inj", "LowParse.Low.Base.Spec.slice_access_eq", "LowParse.Spec.Array.parse_array_kind", "LowParse.Spec.Array.parse_array", "LowParse.Low.Array.clens_array_nth", "LowParse.Low.Array.array_nth_ghost", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.Base.parser_kind_prop_equiv", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "FStar.Pervasives.reveal_opaque", "LowParse.Bytes.bytes", "LowParse.Low.Array.array_nth_ghost''", "LowParse.Low.Base.Spec.gaccessor'", "LowParse.Low.Array.array_nth_ghost'", "LowParse.Low.Base.Spec.gaccessor", "LowParse.Low.Base.accessor" ]	[]	false	false	false	false	false	let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) =	fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@@ inline_let ]let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` (U32.uint_to_t k.parser_kind_low))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_e_app	val mk_e_app (t: term) (args: list term) : Tot term	val mk_e_app (t: term) (args: list term) : Tot term	let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 39, "end_line": 108, "start_col": 0, "start_line": 106 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> args: Prims.list FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "Prims.list", "FStar.Reflection.V2.Derived.mk_app", "FStar.List.Tot.Base.map", "FStar.Stubs.Reflection.V2.Data.argv", "FStar.Pervasives.Native.tuple2", "FStar.Stubs.Reflection.V2.Data.aqualv", "FStar.Pervasives.Native.Mktuple2", "FStar.Stubs.Reflection.V2.Data.Q_Explicit" ]	[]	false	false	false	true	false	let mk_e_app (t: term) (args: list term) : Tot term =	let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.u_unk	val u_unk:universe	val u_unk:universe	let u_unk : universe = pack_universe Uv_Unk	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 43, "end_line": 110, "start_col": 0, "start_line": 110 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	FStar.Stubs.Reflection.Types.universe	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.V2.Builtins.pack_universe", "FStar.Stubs.Reflection.V2.Data.Uv_Unk" ]	[]	false	false	false	true	false	let u_unk:universe =	pack_universe Uv_Unk	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_app_ln	val collect_app_ln : term -> term * list argv	val collect_app_ln : term -> term * list argv	let collect_app_ln = collect_app_ln' []	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 39, "end_line": 98, "start_col": 0, "start_line": 98 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	_: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term * Prims.list FStar.Stubs.Reflection.V2.Data.argv	Prims.Tot	[ "total" ]	[]	[ "FStar.Reflection.V2.Derived.collect_app_ln'", "Prims.Nil", "FStar.Stubs.Reflection.V2.Data.argv" ]	[]	false	false	false	true	false	let collect_app_ln =	collect_app_ln' []	false
LowParse.Low.Array.fst	LowParse.Low.Array.jump_vlarray	val jump_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max}) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u ))	val jump_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max}) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u ))	let jump_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } ) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; jump_synth (jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) ()	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 6, "end_line": 433, "start_col": 0, "start_line": 415 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u inline_for_extraction let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 () inline_for_extraction let validate_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } ) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	array_byte_size_min: Prims.nat -> array_byte_size_max: Prims.nat -> s: LowParse.Spec.Base.serializer p -> elem_count_min: Prims.nat -> elem_count_max: Prims.nat -> u391: u393: Prims.unit { LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true } -> sz32: FStar.UInt32.t{FStar.UInt32.v sz32 == LowParse.Spec.BoundedInt.log256' array_byte_size_max} -> LowParse.Low.Base.jumper (LowParse.Spec.Array.parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u391)	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.unit", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.vldata_vlarray_precond", "FStar.UInt32.t", "Prims.int", "Prims.l_or", "FStar.UInt.size", "FStar.UInt32.n", "Prims.l_and", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "Prims.op_LessThanOrEqual", "FStar.UInt32.v", "LowParse.Spec.BoundedInt.log256'", "LowParse.Low.Combinators.jump_synth", "LowParse.Spec.VLData.parse_bounded_vldata_strong_kind", "LowParse.Spec.List.parse_list_kind", "LowParse.Spec.VLData.parse_bounded_vldata_strong_t", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Spec.List.serialize_list", "LowParse.Spec.Array.vlarray", "LowParse.Spec.VLData.parse_bounded_vldata_strong", "LowParse.Low.VLData.jump_bounded_vldata_strong", "LowParse.Spec.Array.vldata_to_vlarray", "LowParse.Spec.Array.vldata_to_vlarray_inj", "LowParse.Low.Base.jumper", "LowParse.Spec.Array.parse_vlarray_kind", "LowParse.Spec.Array.parse_vlarray" ]	[]	false	false	false	false	false	let jump_vlarray (array_byte_size_min array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t{U32.v sz32 == log256' array_byte_size_max}) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u )) =	vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; jump_synth (jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) ()	false
LowParse.Low.Array.fst	LowParse.Low.Array.valid_array_valid_list'	val valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array' s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x))	val valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array' s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x))	let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos'	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 50, "end_line": 303, "start_col": 0, "start_line": 269 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	s: LowParse.Spec.Base.serializer p -> array_byte_size: Prims.nat -> array_byte_size32: FStar.UInt32.t -> elem_count: Prims.nat -> u257: u269: Prims.unit { LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\ FStar.UInt32.v array_byte_size32 == array_byte_size } -> h: FStar.Monotonic.HyperStack.mem -> input: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t -> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid (LowParse.Spec.Array.parse_array' s array_byte_size elem_count) h input pos) (ensures (let pos' = LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Array.parse_array' s array_byte_size elem_count) h input pos in let x = LowParse.Low.Base.Spec.contents (LowParse.Spec.Array.parse_array' s array_byte_size elem_count) h input pos in FStar.UInt32.v pos' - FStar.UInt32.v pos == array_byte_size /\ LowParse.Low.Base.Spec.valid_list p h input pos pos' /\ LowParse.Low.Base.Spec.contents_list p h input pos pos' == x))	FStar.Pervasives.Lemma	[ "lemma" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Spec.Base.serializer", "Prims.nat", "FStar.UInt32.t", "Prims.unit", "Prims.l_and", "Prims.eq2", "Prims.bool", "LowParse.Spec.Array.fldata_array_precond", "Prims.int", "Prims.l_or", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.UInt.size", "FStar.UInt32.n", "FStar.UInt32.v", "FStar.Monotonic.HyperStack.mem", "LowParse.Slice.srel", "LowParse.Bytes.byte", "LowParse.Slice.slice", "LowParse.Low.List.valid_exact_list_valid_list", "LowParse.Low.Base.Spec.contents_exact_eq", "LowParse.Spec.List.parse_list_kind", "Prims.list", "LowParse.Spec.List.parse_list", "LowParse.Low.Base.Spec.valid_exact_equiv", "LowParse.Low.Base.Spec.valid_facts", "LowParse.Spec.FLData.parse_fldata_kind", "LowParse.Spec.FLData.parse_fldata_strong_t", "LowParse.Spec.List.serialize_list", "LowParse.Spec.FLData.parse_fldata_strong", "LowParse.Low.Combinators.valid_synth", "LowParse.Spec.Array.array", "LowParse.Spec.Array.fldata_to_array", "LowParse.Low.Base.Spec.contents", "LowParse.Spec.Array.parse_array_kind'", "LowParse.Spec.Array.parse_array'", "LowParse.Low.Base.Spec.get_valid_pos", "LowParse.Low.Base.Spec.valid", "Prims.squash", "Prims.op_Subtraction", "LowParse.Low.Base.Spec.valid_list", "LowParse.Low.Base.Spec.contents_list", "Prims.Nil", "FStar.Pervasives.pattern" ]	[]	true	false	true	false	false	let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires (valid (parse_array' s array_byte_size elem_count) h input pos)) (ensures (let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x)) =	let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos'; contents_exact_eq (parse_list p) h input pos pos'; valid_exact_list_valid_list p h input pos pos'	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.shift		val shift : n: Prims.int -> s: FStar.Stubs.Syntax.Syntax.subst_elt -> FStar.Stubs.Syntax.Syntax.subst_elt	let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 17, "end_line": 43, "start_col": 0, "start_line": 37 }	(* Copyright 2008-2018 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. *) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	n: Prims.int -> s: FStar.Stubs.Syntax.Syntax.subst_elt -> FStar.Stubs.Syntax.Syntax.subst_elt	Prims.Tot	[ "total" ]	[]	[ "Prims.int", "FStar.Stubs.Syntax.Syntax.subst_elt", "FStar.Stubs.Reflection.Types.namedv", "FStar.Stubs.Syntax.Syntax.DB", "Prims.op_Addition", "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Syntax.Syntax.DT", "FStar.Stubs.Reflection.Types.universe", "FStar.Stubs.Syntax.Syntax.UN", "FStar.Stubs.Syntax.Syntax.NM", "FStar.Stubs.Reflection.Types.ident", "FStar.Stubs.Syntax.Syntax.UD" ]	[]	false	false	false	true	false	let shift n s =	match s with \| DB i t -> DB (i + n) t \| DT i t -> DT (i + n) t \| UN i t -> UN (i + n) t \| NM x i -> NM x (i + n) \| UD x i -> UD x (i + n) \| NT _ _ -> s	false
LowParse.Low.Array.fst	LowParse.Low.Array.vlarray_nth_compute	val vlarray_nth_compute (a: nat) (b c: U32.t) (bound: Ghost.erased nat { a + ((U32.v b) `Prims.op_Multiply` (U32.v c)) <= Ghost.reveal bound /\ Ghost.reveal bound < 4294967296 }) : Tot (z: U32.t{U32.v z == a + ((U32.v b) `Prims.op_Multiply` (U32.v c))})	val vlarray_nth_compute (a: nat) (b c: U32.t) (bound: Ghost.erased nat { a + ((U32.v b) `Prims.op_Multiply` (U32.v c)) <= Ghost.reveal bound /\ Ghost.reveal bound < 4294967296 }) : Tot (z: U32.t{U32.v z == a + ((U32.v b) `Prims.op_Multiply` (U32.v c))})	let vlarray_nth_compute (a: nat) (b: U32.t) (c: U32.t) (bound: Ghost.erased nat { a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\ Ghost.reveal bound < 4294967296 }) : Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)}) = FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c); uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c); U32.uint_to_t a `U32.add` (b `U32.mul` c)	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 43, "end_line": 589, "start_col": 0, "start_line": 578 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i) let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end let clens_array_nth (t: Type) (elem_count: nat) (i: nat { i < elem_count } ) : Tot (clens (array t elem_count) t) = { clens_cond = (fun _ -> True); clens_get = (fun (l: array t elem_count) -> L.index l i); } #reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat [@"opaque_to_smt"] let array_nth_ghost'' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : GTot (nat) = if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input then (i `Prims.op_Multiply` k.parser_kind_low) else (0) // dummy #reset-options "--z3cliopt smt.arith.nl=false" let array_nth_ghost_correct' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input)) (ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); parser_kind_prop_equiv k p; fldata_to_array_inj s array_byte_size elem_count (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input; let input0 = Seq.slice input 0 array_byte_size in parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0; list_nth_constant_size_parser_correct p input0 i; let off = i `Prims.op_Multiply` k.parser_kind_low in parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) let array_nth_ghost_correct (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) (input: bytes) : Lemma (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)) = reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input); Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input [@"opaque_to_smt"] let array_nth_ghost' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = fun input -> array_nth_ghost_correct s array_byte_size elem_count i input; array_nth_ghost'' s array_byte_size elem_count i input [@"opaque_to_smt"] let array_nth_ghost (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: nat { fldata_array_precond k array_byte_size elem_count == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count }) : Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i)) = reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i); M.distributivity_add_left i 1 k.parser_kind_low; M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count; assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size); parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count); assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x); gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i); array_nth_ghost' s array_byte_size elem_count i module B = LowStar.Buffer inline_for_extraction let array_nth (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (elem_count: nat) (i: U32.t { fldata_array_precond k (array_byte_size) (elem_count) == true /\ array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ U32.v i < elem_count }) : Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i))) = fun #rrel #rel input pos -> reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i)); reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i)); let h = HST.get () in [@inline_let] let _ = parser_kind_prop_equiv k p; valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos; slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos; fldata_to_array_inj s (array_byte_size) (elem_count) (); parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos); list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i) in pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low) module HS = FStar.HyperStack let valid_list_valid_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_exact_list p h input pos pos' ; valid_exact_equiv (parse_list p) h input pos pos' ; let len32 = pos' `U32.sub` pos in list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32)); contents_exact_eq (parse_list p) h input pos pos'; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos let valid_list_valid_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) (pos' : U32.t) : Lemma (requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size))) (ensures ( let x = contents_list p h input pos pos' in L.length x == elem_count /\ U32.v pos' - U32.v pos == array_byte_size /\ valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos' )) = valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_facts (parse_array s array_byte_size elem_count) h input pos let valid_array_valid_list' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array' s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in let x = contents (parse_array' s array_byte_size elem_count) h input pos in valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos; valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos; valid_exact_equiv (parse_list p) h input pos pos' ; contents_exact_eq (parse_list p) h input pos pos' ; valid_exact_list_valid_list p h input pos pos' let valid_array_valid_list (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos: U32.t) : Lemma (requires ( valid (parse_array s array_byte_size elem_count) h input pos )) (ensures ( let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in let x = contents (parse_array s array_byte_size elem_count) h input pos in U32.v pos' - U32.v pos == array_byte_size /\ valid_list p h input pos pos' /\ contents_list p h input pos pos' == x )) = valid_facts (parse_array s array_byte_size elem_count) h input pos; valid_facts (parse_array' s array_byte_size elem_count) h input pos; valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos inline_for_extraction let validate_array' (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array' s array_byte_size elem_count)) = validate_synth (validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32) (fldata_to_array s array_byte_size elem_count ()) () inline_for_extraction let validate_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (validator (parse_array s array_byte_size elem_count)) = if k.parser_kind_metadata = Some ParserKindMetadataTotal then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) () else validate_array' s v array_byte_size array_byte_size32 elem_count u inline_for_extraction let jump_array (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (array_byte_size: nat) (array_byte_size32: U32.t) (elem_count: nat) (u: unit { fldata_array_precond k array_byte_size elem_count == true /\ U32.v array_byte_size32 == array_byte_size }) : Tot (jumper (parse_array s array_byte_size elem_count)) = jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 () inline_for_extraction let validate_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (v: validator p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } ) : Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; validate_synth (validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let jump_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (u: unit { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } ) : Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u)) = vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u; jump_synth (jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ()) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) () inline_for_extraction let finalize_vlarray (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (#rrel #rel: _) (sl: slice rrel rel) (pos pos' : U32.t) : HST.Stack unit (requires (fun h -> vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ ( let vpos1 = U32.v pos + log256' array_byte_size_max in vpos1 < 4294967296 /\ ( let pos1 = U32.uint_to_t vpos1 in let len = U32.v pos' - vpos1 in valid_list p h sl pos1 pos' /\ ( let count = L.length (contents_list p h sl pos1 pos') in writable sl.base (U32.v pos) vpos1 h /\ ((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max)) ))))) (ensures (fun h _ h' -> let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in let l = contents_list p h sl pos1 pos' in B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\ L.length l <= elem_count_max /\ valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos' )) = let h = HST.get () in let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in valid_list_valid_exact_list p h sl pos1 pos'; let l = Ghost.hide (contents_list p h sl pos1 pos') in let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) = valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ; Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l) in vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l); finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ; let h = HST.get () in valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos let clens_vlarray_nth (t: Type) (min max: nat) (i: nat) : Tot (clens (vlarray t min max) t) = { clens_cond = (fun (l: vlarray t min max) -> i < L.length l); clens_get = (fun (l: vlarray t min max) -> L.index l i); } inline_for_extraction let vlarray_list_length (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (#rrel #rel: _) (sl: slice rrel rel) (pos: U32.t) : HST.Stack U32.t (requires (fun h -> vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos )) (ensures (fun h res h' -> let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in B.modifies B.loc_none h h' /\ U32.v res == L.length x /\ U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\ valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\ contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x )) = let h = HST.get () in [@inline_let] let _ : unit = let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in let sq = bytes_of_slice_from h sl pos in valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos; valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos; vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (); parse_synth_eq (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sq; parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq; let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in let Some (ln, _) = psq in list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln)); LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low; let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in let pos' = pos_payload `U32.add` ln in valid_exact_equiv (parse_list p) h sl pos_payload pos'; contents_exact_eq (parse_list p) h sl pos_payload pos'; valid_exact_list_valid_list p h sl pos_payload pos' in [@inline_let] let klow : U32.t = U32.uint_to_t k.parser_kind_low in let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in blen `U32.div` klow #push-options "--z3rlimit 16" [@"opaque_to_smt"] let vlarray_nth_ghost'' (array_byte_size_min: nat) (array_byte_size_max: nat) (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (elem_count_min: nat) (elem_count_max: nat) (i: nat { vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true }) (input: bytes) : GTot (nat) = if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low)) else (0) // dummy #pop-options let uint32_size_intro (x: nat) : Lemma (requires (x < 4294967296)) (ensures (FStar.UInt.size x 32)) = ()	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "LowStar.Buffer", "short_module": "B" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 5, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	a: Prims.nat -> b: FStar.UInt32.t -> c: FStar.UInt32.t -> bound: FStar.Ghost.erased Prims.nat { a + FStar.UInt32.v b * FStar.UInt32.v c <= FStar.Ghost.reveal bound /\ FStar.Ghost.reveal bound < 4294967296 } -> z: FStar.UInt32.t{FStar.UInt32.v z == a + FStar.UInt32.v b * FStar.UInt32.v c}	Prims.Tot	[ "total" ]	[]	[ "Prims.nat", "FStar.UInt32.t", "FStar.Ghost.erased", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Prims.op_Addition", "Prims.op_Multiply", "FStar.UInt32.v", "FStar.Ghost.reveal", "Prims.op_LessThan", "FStar.UInt32.add", "FStar.UInt32.uint_to_t", "FStar.UInt32.mul", "Prims.unit", "LowParse.Low.Array.uint32_size_intro", "FStar.Math.Lemmas.nat_times_nat_is_nat", "Prims.eq2", "Prims.int" ]	[]	false	false	false	false	false	let vlarray_nth_compute (a: nat) (b c: U32.t) (bound: Ghost.erased nat { a + ((U32.v b) `Prims.op_Multiply` (U32.v c)) <= Ghost.reveal bound /\ Ghost.reveal bound < 4294967296 }) : Tot (z: U32.t{U32.v z == a + ((U32.v b) `Prims.op_Multiply` (U32.v c))}) =	FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c); uint32_size_intro ((U32.v b) `Prims.op_Multiply` (U32.v c)); (U32.uint_to_t a) `U32.add` (b `U32.mul` c)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_arr_ln	val collect_arr_ln : typ -> list typ * comp	val collect_arr_ln : typ -> list typ * comp	let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 42, "end_line": 142, "start_col": 0, "start_line": 140 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.typ -> Prims.list FStar.Stubs.Reflection.Types.typ * FStar.Stubs.Reflection.Types.comp	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.typ", "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.Types.comp", "FStar.Pervasives.Native.Mktuple2", "FStar.List.Tot.Base.map", "FStar.Reflection.V2.Derived.type_of_binder", "FStar.Pervasives.Native.tuple2", "FStar.Reflection.V2.Derived.collect_arr_ln_bs" ]	[]	false	false	false	true	false	let collect_arr_ln t =	let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_cons	val mk_cons (h t: term) : term	val mk_cons (h t: term) : term	let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 56, "end_line": 164, "start_col": 0, "start_line": 163 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	h: FStar.Stubs.Reflection.Types.term -> t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.mk_e_app", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Builtins.pack_fv", "FStar.Reflection.Const.cons_qn", "Prims.Cons", "Prims.Nil" ]	[]	false	false	false	true	false	let mk_cons (h t: term) : term =	mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_stringlit	val mk_stringlit (s: string) : term	val mk_stringlit (s: string) : term	let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s))	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 35, "end_line": 158, "start_col": 0, "start_line": 157 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	s: Prims.string -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "Prims.string", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_Const", "FStar.Stubs.Reflection.V2.Data.C_String", "FStar.Stubs.Reflection.Types.term" ]	[]	false	false	false	true	false	let mk_stringlit (s: string) : term =	pack_ln (Tv_Const (C_String s))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.fv_to_string	val fv_to_string (fv: fv) : string	val fv_to_string (fv: fv) : string	let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 62, "end_line": 155, "start_col": 0, "start_line": 155 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t')	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	fv: FStar.Stubs.Reflection.Types.fv -> Prims.string	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.fv", "FStar.Stubs.Reflection.V2.Builtins.implode_qn", "FStar.Stubs.Reflection.V2.Builtins.inspect_fv", "Prims.string" ]	[]	false	false	false	true	false	let fv_to_string (fv: fv) : string =	implode_qn (inspect_fv fv)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_arr_ln_bs	val collect_arr_ln_bs : typ -> list binder * comp	val collect_arr_ln_bs : typ -> list binder * comp	let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 29, "end_line": 137, "start_col": 0, "start_line": 135 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.typ -> Prims.list FStar.Stubs.Reflection.Types.binder * FStar.Stubs.Reflection.Types.comp	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.typ", "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.Types.comp", "FStar.Pervasives.Native.Mktuple2", "FStar.List.Tot.Base.rev", "FStar.Pervasives.Native.tuple2", "FStar.Reflection.V2.Derived.collect_arr'", "Prims.Nil", "FStar.Stubs.Reflection.V2.Builtins.pack_comp", "FStar.Stubs.Reflection.V2.Data.C_Total" ]	[]	false	false	false	true	false	let collect_arr_ln_bs t =	let bs, c = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_strcat	val mk_strcat (t1 t2: term) : term	val mk_strcat (t1 t2: term) : term	let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 71, "end_line": 161, "start_col": 0, "start_line": 160 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s))	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t1: FStar.Stubs.Reflection.Types.term -> t2: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.mk_e_app", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Builtins.pack_fv", "Prims.Cons", "Prims.string", "Prims.Nil" ]	[]	false	false	false	true	false	let mk_strcat (t1 t2: term) : term =	mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_abs_ln	val collect_abs_ln : term -> list binder * term	val collect_abs_ln : term -> list binder * term	let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t')	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 30, "end_line": 153, "start_col": 0, "start_line": 151 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> Prims.list FStar.Stubs.Reflection.Types.binder * FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Pervasives.Native.Mktuple2", "FStar.List.Tot.Base.rev", "FStar.Pervasives.Native.tuple2", "FStar.Reflection.V2.Derived.collect_abs'", "Prims.Nil" ]	[]	false	false	false	true	false	let collect_abs_ln t =	let bs, t' = collect_abs' [] t in (List.Tot.Base.rev bs, t')	false
LowParse.Low.Array.fst	LowParse.Low.Array.list_nth_constant_size_parser_correct	val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i)	val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i)	let rec list_nth_constant_size_parser_correct #k #t p b i = parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else begin M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1) end	{ "file_name": "src/lowparse/LowParse.Low.Array.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }	{ "end_col": 5, "end_line": 47, "start_col": 0, "start_line": 39 }	module LowParse.Low.Array include LowParse.Spec.Array include LowParse.Low.List include LowParse.Low.VLData module L = FStar.List.Tot module M = LowParse.Math module U32 = FStar.UInt32 module HST = FStar.HyperStack.ST #reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16" val list_nth_constant_size_parser_correct (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes) (i: nat) : Lemma (requires ( k.parser_kind_high == Some k.parser_kind_low /\ Some? (parse (parse_list p) b) /\ ( let (Some (l, _)) = parse (parse_list p) b in i < L.length l ))) (ensures ( let j = i `Prims.op_Multiply` k.parser_kind_low in 0 <= j /\ j + k.parser_kind_low <= Seq.length b /\ ( let b' = Seq.slice b j (Seq.length b) in Some? (parse p b') /\ ( let (Some (l, _)) = parse (parse_list p) b in let (Some (x, _)) = parse p b' in x == L.index l i )))) (decreases i)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "LowStar.Buffer.fst.checked", "LowParse.Spec.Array.fst.checked", "LowParse.Math.fst.checked", "LowParse.Low.VLData.fst.checked", "LowParse.Low.List.fst.checked", "FStar.UInt32.fsti.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Int.Cast.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked" ], "interface_file": false, "source_file": "LowParse.Low.Array.fst" }	[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.UInt32", "short_module": "U32" }, { "abbrev": true, "full_module": "LowParse.Math", "short_module": "M" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "LowParse.Low.VLData", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low.List", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Spec.Array", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "short_module": null }, { "abbrev": false, "full_module": "LowParse.Low", "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 } ]	{ "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": [ "smt.arith.nl=false" ], "z3refresh": false, "z3rlimit": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }	false	p: LowParse.Spec.Base.parser k t -> b: LowParse.Bytes.bytes -> i: Prims.nat -> FStar.Pervasives.Lemma (requires Mkparser_kind'?.parser_kind_high k == FStar.Pervasives.Native.Some (Mkparser_kind'?.parser_kind_low k) /\ Some? (LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) b) /\ (let _ = LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) b in (let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ l _) = _ in i < FStar.List.Tot.Base.length l) <: Prims.logical)) (ensures (let j = i * Mkparser_kind'?.parser_kind_low k in 0 <= j /\ j + Mkparser_kind'?.parser_kind_low k <= FStar.Seq.Base.length b /\ (let b' = FStar.Seq.Base.slice b j (FStar.Seq.Base.length b) in Some? (LowParse.Spec.Base.parse p b') /\ (let _ = LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) b in (let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ l _) = _ in let _ = LowParse.Spec.Base.parse p b' in (let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x _) = _ in x == FStar.List.Tot.Base.index l i) <: Prims.logical) <: Prims.logical)))) (decreases i)	FStar.Pervasives.Lemma	[ "lemma", "" ]	[]	[ "LowParse.Spec.Base.parser_kind", "LowParse.Spec.Base.parser", "LowParse.Bytes.bytes", "Prims.nat", "Prims.op_Equality", "Prims.int", "Prims.bool", "LowParse.Low.Array.list_nth_constant_size_parser_correct", "FStar.Seq.Base.slice", "LowParse.Bytes.byte", "LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low", "FStar.Seq.Base.length", "Prims.op_Subtraction", "Prims.unit", "LowParse.Math.mult_decomp", "LowParse.Spec.List.parse_list_eq", "LowParse.Spec.Base.parser_kind_prop_equiv" ]	[ "recursion" ]	false	false	true	false	false	let rec list_nth_constant_size_parser_correct #k #t p b i =	parser_kind_prop_equiv k p; parse_list_eq p b; if i = 0 then () else (M.mult_decomp i k.parser_kind_low; list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_implicit_binder	val mk_implicit_binder (nm: string) (sort: typ) : binder	val mk_implicit_binder (nm: string) (sort: typ) : binder	let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; }	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 3, "end_line": 69, "start_col": 0, "start_line": 63 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? *) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	nm: Prims.string -> sort: FStar.Stubs.Reflection.Types.typ -> FStar.Stubs.Reflection.Types.binder	Prims.Tot	[ "total" ]	[]	[ "Prims.string", "FStar.Stubs.Reflection.Types.typ", "FStar.Stubs.Reflection.V2.Builtins.pack_binder", "FStar.Stubs.Reflection.V2.Data.Mkbinder_view", "FStar.Stubs.Reflection.V2.Data.Q_Implicit", "Prims.Nil", "FStar.Stubs.Reflection.Types.term", "FStar.Sealed.seal", "FStar.Stubs.Reflection.Types.binder" ]	[]	false	false	false	true	false	let mk_implicit_binder (nm: string) (sort: typ) : binder =	pack_binder ({ ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort })	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_cons_t	val mk_cons_t (ty h t: term) : term	val mk_cons_t (ty h t: term) : term	let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 100, "end_line": 167, "start_col": 0, "start_line": 166 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	ty: FStar.Stubs.Reflection.Types.term -> h: FStar.Stubs.Reflection.Types.term -> t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.mk_app", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Builtins.pack_fv", "FStar.Reflection.Const.cons_qn", "Prims.Cons", "FStar.Stubs.Reflection.V2.Data.argv", "FStar.Pervasives.Native.Mktuple2", "FStar.Stubs.Reflection.V2.Data.aqualv", "FStar.Stubs.Reflection.V2.Data.Q_Implicit", "FStar.Stubs.Reflection.V2.Data.Q_Explicit", "Prims.Nil" ]	[]	false	false	false	true	false	let mk_cons_t (ty h t: term) : term =	mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.is_fvar	val is_fvar (t: term) (nm: string) : bool	val is_fvar (t: term) (nm: string) : bool	let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 16, "end_line": 234, "start_col": 0, "start_line": 230 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name).	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> nm: Prims.string -> Prims.bool	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "Prims.string", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Stubs.Reflection.Types.fv", "Prims.op_Equality", "FStar.Stubs.Reflection.V2.Builtins.implode_qn", "FStar.Stubs.Reflection.V2.Builtins.inspect_fv", "FStar.Stubs.Reflection.V2.Data.universes", "FStar.Stubs.Reflection.V2.Data.term_view", "Prims.bool" ]	[]	false	false	false	true	false	let is_fvar (t: term) (nm: string) : bool =	match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.is_uvar	val is_uvar (t: term) : bool	val is_uvar (t: term) : bool	let is_uvar (t : term) : bool = match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 16, "end_line": 246, "start_col": 0, "start_line": 243 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name). Ignores universes and ascriptions. ) let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false (* Checks if a term `t` is equal to any FV (a top level name) from those given in the list. Ignores universes and ascriptions. *) let rec is_any_fvar (t : term) (nms:list string) : bool = match nms with \| [] -> false \| v::vs -> is_fvar t v \|\| is_any_fvar t vs	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> Prims.bool	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.inspect_ln", "FStar.Reflection.V2.Derived.head", "Prims.nat", "FStar.Stubs.Reflection.Types.ctx_uvar_and_subst", "FStar.Stubs.Reflection.V2.Data.term_view", "Prims.bool" ]	[]	false	false	false	true	false	let is_uvar (t: term) : bool =	match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_binder	val mk_binder (nm: string) (sort: typ) : simple_binder	val mk_binder (nm: string) (sort: typ) : simple_binder	let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 16, "end_line": 61, "start_col": 0, "start_line": 52 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments?	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	nm: Prims.string -> sort: FStar.Stubs.Reflection.Types.typ -> FStar.Stubs.Reflection.V2.Data.simple_binder	Prims.Tot	[ "total" ]	[]	[ "Prims.string", "FStar.Stubs.Reflection.Types.typ", "FStar.Stubs.Reflection.V2.Builtins.pack_binder", "Prims.unit", "FStar.Stubs.Reflection.V2.Builtins.inspect_pack_binder", "FStar.Stubs.Reflection.V2.Data.binder_view", "FStar.Stubs.Reflection.V2.Data.Mkbinder_view", "FStar.Stubs.Reflection.V2.Data.Q_Explicit", "Prims.Nil", "FStar.Stubs.Reflection.Types.term", "FStar.Sealed.seal", "FStar.Stubs.Reflection.V2.Data.simple_binder" ]	[]	false	false	false	true	false	let mk_binder (nm: string) (sort: typ) : simple_binder =	let bv:binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort } in inspect_pack_binder bv; pack_binder bv	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.un_uinst	val un_uinst (t: term) : term	val un_uinst (t: term) : term	let un_uinst (t:term) : term = match inspect_ln t with \| Tv_UInst fv _ -> pack_ln (Tv_FVar fv) \| _ -> t	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 10, "end_line": 263, "start_col": 0, "start_line": 260 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name). Ignores universes and ascriptions. ) let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false (* Checks if a term `t` is equal to any FV (a top level name) from those given in the list. Ignores universes and ascriptions. ) let rec is_any_fvar (t : term) (nms:list string) : bool = match nms with \| [] -> false \| v::vs -> is_fvar t v \|\| is_any_fvar t vs let is_uvar (t : term) : bool = match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false let binder_set_qual (q:aqualv) (b:binder) : Tot binder = let bview = inspect_binder b in pack_binder { bview with qual=q } (* Set a vconfig for a sigelt *) val add_check_with : vconfig -> sigelt -> Tot sigelt let add_check_with vcfg se = let attrs = sigelt_attrs se in let vcfg_t = embed_vconfig vcfg in let t = `(check_with (`#vcfg_t)) in set_sigelt_attrs (t :: attrs) se	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.inspect_ln", "FStar.Stubs.Reflection.Types.fv", "FStar.Stubs.Reflection.V2.Data.universes", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Data.term_view" ]	[]	false	false	false	true	false	let un_uinst (t: term) : term =	match inspect_ln t with \| Tv_UInst fv _ -> pack_ln (Tv_FVar fv) \| _ -> t	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.flatten_name	val flatten_name : name -> Tot string	val flatten_name : name -> Tot string	let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 40, "end_line": 88, "start_col": 0, "start_line": 84 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? *) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	ns: FStar.Stubs.Reflection.Types.name -> Prims.string	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.name", "Prims.string", "Prims.list", "Prims.op_Hat", "FStar.Reflection.V2.Derived.flatten_name" ]	[ "recursion" ]	false	false	false	true	false	let rec flatten_name ns =	match ns with \| [] -> "" \| [n] -> n \| n :: ns -> n ^ "." ^ flatten_name ns	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_app_ln'	val collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t)	val collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t)	let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 20, "end_line": 95, "start_col": 0, "start_line": 91 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? *) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	args: Prims.list FStar.Stubs.Reflection.V2.Data.argv -> t: FStar.Stubs.Reflection.Types.term -> Prims.Tot (FStar.Stubs.Reflection.Types.term * Prims.list FStar.Stubs.Reflection.V2.Data.argv)	Prims.Tot	[ "total", "" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.V2.Data.argv", "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Reflection.V2.Derived.collect_app_ln'", "Prims.Cons", "FStar.Stubs.Reflection.V2.Data.term_view", "FStar.Pervasives.Native.Mktuple2", "FStar.Pervasives.Native.tuple2" ]	[ "recursion" ]	false	false	false	true	false	let rec collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t) =	match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r :: args) l \| _ -> (t, args)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.add_check_with	val add_check_with : vconfig -> sigelt -> Tot sigelt	val add_check_with : vconfig -> sigelt -> Tot sigelt	let add_check_with vcfg se = let attrs = sigelt_attrs se in let vcfg_t = embed_vconfig vcfg in let t = `(check_with (`#vcfg_t)) in set_sigelt_attrs (t :: attrs) se	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 34, "end_line": 258, "start_col": 0, "start_line": 254 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name). Ignores universes and ascriptions. ) let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false (* Checks if a term `t` is equal to any FV (a top level name) from those given in the list. Ignores universes and ascriptions. ) let rec is_any_fvar (t : term) (nms:list string) : bool = match nms with \| [] -> false \| v::vs -> is_fvar t v \|\| is_any_fvar t vs let is_uvar (t : term) : bool = match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false let binder_set_qual (q:aqualv) (b:binder) : Tot binder = let bview = inspect_binder b in pack_binder { bview with qual=q } (* Set a vconfig for a sigelt *)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	vcfg: FStar.VConfig.vconfig -> se: FStar.Stubs.Reflection.Types.sigelt -> FStar.Stubs.Reflection.Types.sigelt	Prims.Tot	[ "total" ]	[]	[ "FStar.VConfig.vconfig", "FStar.Stubs.Reflection.Types.sigelt", "FStar.Stubs.Reflection.V2.Builtins.set_sigelt_attrs", "Prims.Cons", "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.embed_vconfig", "Prims.list", "FStar.Stubs.Reflection.V2.Builtins.sigelt_attrs" ]	[]	false	false	false	true	false	let add_check_with vcfg se =	let attrs = sigelt_attrs se in let vcfg_t = embed_vconfig vcfg in let t = `(check_with (`#vcfg_t)) in set_sigelt_attrs (t :: attrs) se	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.binder_set_qual	val binder_set_qual (q: aqualv) (b: binder) : Tot binder	val binder_set_qual (q: aqualv) (b: binder) : Tot binder	let binder_set_qual (q:aqualv) (b:binder) : Tot binder = let bview = inspect_binder b in pack_binder { bview with qual=q }	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 35, "end_line": 250, "start_col": 0, "start_line": 248 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name). Ignores universes and ascriptions. ) let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false (* Checks if a term `t` is equal to any FV (a top level name) from those given in the list. Ignores universes and ascriptions. *) let rec is_any_fvar (t : term) (nms:list string) : bool = match nms with \| [] -> false \| v::vs -> is_fvar t v \|\| is_any_fvar t vs let is_uvar (t : term) : bool = match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	q: FStar.Stubs.Reflection.V2.Data.aqualv -> b: FStar.Stubs.Reflection.Types.binder -> FStar.Stubs.Reflection.Types.binder	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.V2.Data.aqualv", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.V2.Builtins.pack_binder", "FStar.Stubs.Reflection.V2.Data.Mkbinder_view", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinder_view__item__sort", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinder_view__item__attrs", "FStar.Stubs.Reflection.V2.Data.__proj__Mkbinder_view__item__ppname", "FStar.Stubs.Reflection.V2.Data.binder_view", "Prims.precedes", "FStar.Stubs.Reflection.V2.Builtins.inspect_binder" ]	[]	false	false	false	true	false	let binder_set_qual (q: aqualv) (b: binder) : Tot binder =	let bview = inspect_binder b in pack_binder ({ bview with qual = q })	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_app	val mk_app (t: term) (args: list argv) : Tot term (decreases args)	val mk_app (t: term) (args: list argv) : Tot term (decreases args)	let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 49, "end_line": 103, "start_col": 0, "start_line": 100 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' []	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> args: Prims.list FStar.Stubs.Reflection.V2.Data.argv -> Prims.Tot FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total", "" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "Prims.list", "FStar.Stubs.Reflection.V2.Data.argv", "FStar.Reflection.V2.Derived.mk_app", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_App" ]	[ "recursion" ]	false	false	false	true	false	let rec mk_app (t: term) (args: list argv) : Tot term (decreases args) =	match args with \| [] -> t \| x :: xs -> mk_app (pack_ln (Tv_App t x)) xs	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.unsquash_term	val unsquash_term (t: term) : option term	val unsquash_term (t: term) : option term	let unsquash_term (t : term) : option term = match inspect_ln_unascribe t with \| Tv_App l (r, Q_Explicit) -> if is_name_imp squash_qn l then Some r else None \| _ -> None	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 15, "end_line": 288, "start_col": 0, "start_line": 282 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None let mkpair (t1 t2 : term) : term = mktuple_n [t1;t2] let rec head (t : term) : term = match inspect_ln t with \| Tv_Match t _ _ \| Tv_Let _ _ _ t _ \| Tv_Abs _ t \| Tv_Refine _ t \| Tv_App t _ \| Tv_AscribedT t _ _ _ \| Tv_AscribedC t _ _ _ -> head t \| Tv_Unknown \| Tv_Uvar _ _ \| Tv_Const _ \| Tv_Type _ \| Tv_Var _ \| Tv_BVar _ \| Tv_FVar _ \| Tv_UInst _ _ \| Tv_Arrow _ _ \| Tv_Unsupp -> t (** Checks if a term `t` is equal to some FV (a top level name). Ignores universes and ascriptions. ) let is_fvar (t : term) (nm:string) : bool = match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm \| _ -> false (* Checks if a term `t` is equal to any FV (a top level name) from those given in the list. Ignores universes and ascriptions. ) let rec is_any_fvar (t : term) (nms:list string) : bool = match nms with \| [] -> false \| v::vs -> is_fvar t v \|\| is_any_fvar t vs let is_uvar (t : term) : bool = match inspect_ln (head t) with \| Tv_Uvar _ _ -> true \| _ -> false let binder_set_qual (q:aqualv) (b:binder) : Tot binder = let bview = inspect_binder b in pack_binder { bview with qual=q } (* Set a vconfig for a sigelt ) val add_check_with : vconfig -> sigelt -> Tot sigelt let add_check_with vcfg se = let attrs = sigelt_attrs se in let vcfg_t = embed_vconfig vcfg in let t = `(check_with (`#vcfg_t)) in set_sigelt_attrs (t :: attrs) se let un_uinst (t:term) : term = match inspect_ln t with \| Tv_UInst fv _ -> pack_ln (Tv_FVar fv) \| _ -> t ( Returns [true] iff the term [t] is just the name [nm], though possibly universe-instantiated and applied to some implicit arguments. ) let rec is_name_imp (nm : name) (t : term) : bool = begin match inspect_ln_unascribe t with \| Tv_FVar fv \| Tv_UInst fv _ -> if inspect_fv fv = nm then true else false \| Tv_App l (_, Q_Implicit) -> is_name_imp nm l \| _ -> false end ( If t is of the shape [squash t'], return [Some t'],	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> FStar.Pervasives.Native.option FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Reflection.V2.Derived.is_name_imp", "FStar.Reflection.Const.squash_qn", "FStar.Pervasives.Native.Some", "Prims.bool", "FStar.Pervasives.Native.None", "FStar.Pervasives.Native.option", "FStar.Stubs.Reflection.V2.Data.term_view" ]	[]	false	false	false	true	false	let unsquash_term (t: term) : option term =	match inspect_ln_unascribe t with \| Tv_App l (r, Q_Explicit) -> if is_name_imp squash_qn l then Some r else None \| _ -> None	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_arr_ln	val mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs)	val mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs)	let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 78, "end_line": 120, "start_col": 0, "start_line": 117 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	bs: Prims.list FStar.Stubs.Reflection.Types.binder {~(Nil? bs)} -> cod: FStar.Stubs.Reflection.Types.comp -> Prims.Tot FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total", "" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.binder", "Prims.l_not", "Prims.b2t", "Prims.uu___is_Nil", "FStar.Stubs.Reflection.Types.comp", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_Arrow", "FStar.Stubs.Reflection.V2.Builtins.pack_comp", "FStar.Stubs.Reflection.V2.Data.C_Total", "FStar.Reflection.V2.Derived.mk_arr_ln", "FStar.Stubs.Reflection.Types.term" ]	[ "recursion" ]	false	false	false	false	false	let rec mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs) =	match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| b :: bs -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_tot_arr_ln	val mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs)	val mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs)	let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 82, "end_line": 115, "start_col": 0, "start_line": 112 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	bs: Prims.list FStar.Stubs.Reflection.Types.binder -> cod: FStar.Stubs.Reflection.Types.term -> Prims.Tot FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total", "" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_Arrow", "FStar.Stubs.Reflection.V2.Builtins.pack_comp", "FStar.Stubs.Reflection.V2.Data.C_Total", "FStar.Reflection.V2.Derived.mk_tot_arr_ln" ]	[ "recursion" ]	false	false	false	true	false	let rec mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs) =	match bs with \| [] -> cod \| b :: bs -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_abs'	val collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t)	val collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t)	let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 18, "end_line": 148, "start_col": 0, "start_line": 144 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	bs: Prims.list FStar.Stubs.Reflection.Types.binder -> t: FStar.Stubs.Reflection.Types.term -> Prims.Tot (Prims.list FStar.Stubs.Reflection.Types.binder * FStar.Stubs.Reflection.Types.term)	Prims.Tot	[ "total", "" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.Types.term", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Reflection.V2.Derived.collect_abs'", "Prims.Cons", "FStar.Stubs.Reflection.V2.Data.term_view", "FStar.Pervasives.Native.Mktuple2", "FStar.Pervasives.Native.tuple2" ]	[ "recursion" ]	false	false	false	true	false	let rec collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t) =	match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b :: bs) t' \| _ -> (bs, t)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.collect_arr'	val collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c)	val collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c)	let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 7, "end_line": 132, "start_col": 0, "start_line": 122 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	bs: Prims.list FStar.Stubs.Reflection.Types.binder -> c: FStar.Stubs.Reflection.Types.comp -> Prims.Tot (Prims.list FStar.Stubs.Reflection.Types.binder * FStar.Stubs.Reflection.Types.comp)	Prims.Tot	[ "total", "" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.binder", "FStar.Stubs.Reflection.Types.comp", "FStar.Stubs.Reflection.V2.Builtins.inspect_comp", "FStar.Stubs.Reflection.Types.typ", "FStar.Reflection.V2.Derived.inspect_ln_unascribe", "FStar.Reflection.V2.Derived.collect_arr'", "Prims.Cons", "FStar.Stubs.Reflection.V2.Data.term_view", "FStar.Pervasives.Native.Mktuple2", "FStar.Pervasives.Native.tuple2", "FStar.Stubs.Reflection.V2.Data.comp_view" ]	[ "recursion" ]	false	false	false	true	false	let rec collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c) =	match inspect_comp c with \| C_Total t -> (match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b :: bs) c \| _ -> (bs, c)) \| _ -> (bs, c)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.destruct_tuple	val destruct_tuple (t: term) : option (list term)	val destruct_tuple (t: term) : option (list term)	let destruct_tuple (t : term) : option (list term) = let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 15, "end_line": 202, "start_col": 0, "start_line": 190 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts) let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	t: FStar.Stubs.Reflection.Types.term -> FStar.Pervasives.Native.option (Prims.list FStar.Stubs.Reflection.Types.term)	Prims.Tot	[ "total" ]	[]	[ "FStar.Stubs.Reflection.Types.term", "Prims.list", "FStar.Stubs.Reflection.V2.Data.argv", "FStar.Stubs.Reflection.V2.Builtins.inspect_ln", "FStar.Stubs.Reflection.Types.fv", "FStar.List.Tot.Base.mem", "Prims.string", "FStar.Stubs.Reflection.V2.Builtins.inspect_fv", "Prims.Cons", "FStar.Reflection.Const.mktuple2_qn", "FStar.Reflection.Const.mktuple3_qn", "FStar.Reflection.Const.mktuple4_qn", "FStar.Reflection.Const.mktuple5_qn", "FStar.Reflection.Const.mktuple6_qn", "FStar.Reflection.Const.mktuple7_qn", "FStar.Reflection.Const.mktuple8_qn", "Prims.Nil", "FStar.Pervasives.Native.Some", "FStar.List.Tot.Base.concatMap", "FStar.Pervasives.Native.tuple2", "FStar.Stubs.Reflection.V2.Data.aqualv", "Prims.bool", "FStar.Pervasives.Native.None", "FStar.Pervasives.Native.option", "FStar.Stubs.Reflection.V2.Data.term_view", "FStar.Reflection.V2.Derived.collect_app_ln" ]	[]	false	false	false	true	false	let destruct_tuple (t: term) : option (list term) =	let head, args = collect_app_ln t in match inspect_ln head with \| Tv_FVar fv -> if List.Tot.Base.mem (inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn; mktuple6_qn; mktuple7_qn; mktuple8_qn] then Some (List.Tot.Base.concatMap (fun (t, q) -> match q with \| Q_Explicit -> [t] \| _ -> []) args) else None \| _ -> None	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mk_list	val mk_list (ts: list term) : term	val mk_list (ts: list term) : term	let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts)	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 37, "end_line": 172, "start_col": 0, "start_line": 169 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	ts: Prims.list FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.term", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Builtins.pack_fv", "FStar.Reflection.Const.nil_qn", "FStar.Reflection.V2.Derived.mk_cons", "FStar.Reflection.V2.Derived.mk_list" ]	[ "recursion" ]	false	false	false	true	false	let rec mk_list (ts: list term) : term =	match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t :: ts -> mk_cons t (mk_list ts)	false
FStar.Reflection.V2.Derived.fst	FStar.Reflection.V2.Derived.mktuple_n	val mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term	val mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term	let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term = match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> begin let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts end	{ "file_name": "ulib/FStar.Reflection.V2.Derived.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }	{ "end_col": 14, "end_line": 188, "start_col": 0, "start_line": 174 }	(* Copyright 2008-2018 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. ) module FStar.Reflection.V2.Derived open FStar.Stubs.Reflection.Types open FStar.Reflection.Const open FStar.Stubs.Reflection.V2.Builtins open FStar.Stubs.Reflection.V2.Data open FStar.Order open FStar.VConfig let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} = match inspect_ln t with \| Tv_AscribedT t' _ _ _ \| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t' \| tv -> tv let compare_bv (v1 v2 : bv) : order = Order.compare_int (inspect_bv v1).index (inspect_bv v2).index let compare_namedv (v1 v2 : namedv) : order = Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq let shift n s = match s with \| DB i t -> DB (i+n) t \| DT i t -> DT (i+n) t \| UN i t -> UN (i+n) t \| NM x i -> NM x (i+n) \| UD x i -> UD x (i+n) \| NT _ _ -> s let shift_subst n s = List.Tot.map (shift n) s let subst1 (n:namedv) (t1:term) (t2:term) : term = subst_term [NT n t1] t2 ( * AR: add versions that take attributes as arguments? ) let mk_binder (nm : string) (sort : typ) : simple_binder = let bv : binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort; } in inspect_pack_binder bv; pack_binder bv let mk_implicit_binder (nm : string) (sort : typ) : binder = pack_binder { ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort; } let push_binding (e:env) (b:binding) : env = let nv : namedv = pack_namedv { uniq = b.uniq; sort = seal b.sort; ppname = b.ppname; } in push_namedv e nv let type_of_binder (b : binder) : typ = (inspect_binder b).sort val flatten_name : name -> Tot string let rec flatten_name ns = match ns with \| [] -> "" \| [n] -> n \| n::ns -> n ^ "." ^ flatten_name ns ( Helpers for dealing with nested applications and arrows ) let rec collect_app_ln' (args : list argv) (t : term) : Tot (term list argv) (decreases t) = match inspect_ln_unascribe t with \| Tv_App l r -> collect_app_ln' (r::args) l \| _ -> (t, args) val collect_app_ln : term -> term * list argv let collect_app_ln = collect_app_ln' [] let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) = match args with \| [] -> t \| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs // Helper for when all arguments are explicit let mk_e_app (t : term) (args : list term) : Tot term = let e t = (t, Q_Explicit) in mk_app t (List.Tot.Base.map e args) let u_unk : universe = pack_universe Uv_Unk let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) = match bs with \| [] -> cod \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) = match bs with \| [b] -> pack_ln (Tv_Arrow b cod) \| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod)))) let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) = begin match inspect_comp c with \| C_Total t -> begin match inspect_ln_unascribe t with \| Tv_Arrow b c -> collect_arr' (b::bs) c \| _ -> (bs, c) end \| _ -> (bs, c) end val collect_arr_ln_bs : typ -> list binder * comp let collect_arr_ln_bs t = let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in (List.Tot.Base.rev bs, c) val collect_arr_ln : typ -> list typ * comp let collect_arr_ln t = let bs, c = collect_arr_ln_bs t in List.Tot.Base.map type_of_binder bs, c let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) = match inspect_ln_unascribe t with \| Tv_Abs b t' -> collect_abs' (b::bs) t' \| _ -> (bs, t) val collect_abs_ln : term -> list binder * term let collect_abs_ln t = let (bs, t') = collect_abs' [] t in (List.Tot.Base.rev bs, t') let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv) let mk_stringlit (s : string) : term = pack_ln (Tv_Const (C_String s)) let mk_strcat (t1 t2 : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2] let mk_cons (h t : term) : term = mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t] let mk_cons_t (ty h t : term) : term = mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)] let rec mk_list (ts : list term) : term = match ts with \| [] -> pack_ln (Tv_FVar (pack_fv nil_qn)) \| t::ts -> mk_cons t (mk_list ts)	{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.VConfig.fsti.checked", "FStar.Stubs.Reflection.V2.Data.fsti.checked", "FStar.Stubs.Reflection.V2.Builtins.fsti.checked", "FStar.Stubs.Reflection.Types.fsti.checked", "FStar.Reflection.Const.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Order.fst.checked", "FStar.List.Tot.Base.fst.checked", "FStar.List.Tot.fst.checked" ], "interface_file": false, "source_file": "FStar.Reflection.V2.Derived.fst" }	[ { "abbrev": false, "full_module": "FStar.VConfig", "short_module": null }, { "abbrev": false, "full_module": "FStar.Order", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Data", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.V2.Builtins", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.Const", "short_module": null }, { "abbrev": false, "full_module": "FStar.Stubs.Reflection.Types", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "short_module": null }, { "abbrev": false, "full_module": "FStar.Reflection.V2", "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 } ]	{ "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" }	false	ts: Prims.list FStar.Stubs.Reflection.Types.term {FStar.List.Tot.Base.length ts <= 8} -> FStar.Stubs.Reflection.Types.term	Prims.Tot	[ "total" ]	[]	[ "Prims.list", "FStar.Stubs.Reflection.Types.term", "Prims.b2t", "Prims.op_LessThanOrEqual", "FStar.List.Tot.Base.length", "FStar.Stubs.Reflection.V2.Builtins.pack_ln", "FStar.Stubs.Reflection.V2.Data.Tv_Const", "FStar.Stubs.Reflection.V2.Data.C_Unit", "Prims.int", "FStar.Reflection.V2.Derived.mk_e_app", "FStar.Stubs.Reflection.V2.Data.Tv_FVar", "FStar.Stubs.Reflection.V2.Builtins.pack_fv", "FStar.Stubs.Reflection.Types.name", "FStar.Reflection.Const.mktuple2_qn", "FStar.Reflection.Const.mktuple3_qn", "FStar.Reflection.Const.mktuple4_qn", "FStar.Reflection.Const.mktuple5_qn", "FStar.Reflection.Const.mktuple6_qn", "FStar.Reflection.Const.mktuple7_qn", "FStar.Reflection.Const.mktuple8_qn" ]	[]	false	false	false	false	false	let mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term =	match List.Tot.Base.length ts with \| 0 -> pack_ln (Tv_Const C_Unit) \| 1 -> let [x] = ts in x \| n -> let qn = match n with \| 2 -> mktuple2_qn \| 3 -> mktuple3_qn \| 4 -> mktuple4_qn \| 5 -> mktuple5_qn \| 6 -> mktuple6_qn \| 7 -> mktuple7_qn \| 8 -> mktuple8_qn in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts	false

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.